@zerodep-dev/vue-tsx-pro-tsx 0.0.0-stage → 0.1.0

package/dist/vite.d.ts

@@ -0,0 +1,31 @@
+import { Plugin } from "vite";
+import { VueJSXPluginOptions } from "@vue/babel-plugin-jsx";
+//#region src/vite/workspace.d.ts
+/** 解析 @zerodep-dev/vue-tsx-pro-* 用源码；开发与测试时桶文件的具名导入改成直接导入（见文件开头） */
+export declare function workspaceSource(): Plugin;
+//#endregion
+//#region src/vite/index.d.ts
+/** vueTsxPro() 的选项；都不写就是应用的默认配置 */
+export interface VueTsxProOptions {
+  /**
+   * 渲染优化，默认 true：组件子节点的插槽标 $stable、JSX 属性里的函数与常量每个实例只建一次，
+   * 父组件因为别的状态重新渲染时子组件不再跟着重做（见 RUNES.md）。界面要读响应式数据；
+   * 怀疑哪里因此没更新时，传 false 对比
+   */
+  optimize?: boolean;
+  /** Vue JSX 插件（@vue/babel-plugin-jsx）的选项 */
+  jsx?: VueJSXPluginOptions;
+  /**
+   * 开发服务器把编译结果存在磁盘上（cacheDir/vue-tsx-pro），重启后没改过的文件不再编译，默认 true。
+   * 构建与 Vitest 不用它（Vitest 有自己的模块缓存）
+   */
+  cache?: boolean;
+  /**
+   * 在工作线程里并行编译（构建与开发服务器；Vitest 本来就是多进程，不用），默认 true。
+   * 选项里有函数时不能复制到线程，自动在主线程编译
+   */
+  parallel?: boolean;
+}
+/** Vite 预设：`plugins: [vueTsxPro()]` */
+export declare function vueTsxPro(options?: VueTsxProOptions): Plugin[];
+//#endregion

package/dist/vite.js

@@ -0,0 +1,509 @@
+import { n as languageOf } from "./detect-s3UM7xuN.js";
+import { t as SSR_REGISTER_CODE } from "./ssr-register-CZ_lIN2f.js";
+import { normalizePath, parseSync } from "vite";
+import { availableParallelism } from "node:os";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+//#region src/vite/cache-key.ts
+/**
+* Vitest 的文件模块缓存（fsModuleCache）按源文件内容命中，不知道编译器变了：
+* 升级本包、或在本仓库改了编译器后，会继续用旧的编译结果。这里算出编译器代码的哈希，
+* 由预设通过 configureVitest 加进缓存键（见 index.ts）。
+*/
+let cached;
+/** 编译器代码的哈希（进程内只算一次） */
+function compilerCacheKey() {
+	return cached ??= hashFiles(compilerFiles());
+}
+/**
+* 产物：dist 下的全部 js（编译器打进了共享 chunk）；仓库源码：编译器与 Vite 预设的源文件
+*/
+function compilerFiles() {
+	const here = dirname(fileURLToPath(import.meta.url));
+	return (here.replaceAll("\\", "/").endsWith("/src/vite") ? [here, join(here, "../compiler")] : [here]).flatMap((directory) => readdirSync(directory).filter((file) => /\.(js|ts)$/.test(file) && !file.endsWith(".d.ts")).map((file) => join(directory, file)));
+}
+function hashFiles(files) {
+	const hash = createHash("sha1");
+	for (const file of files.sort()) hash.update(readFileSync(file));
+	return hash.digest("hex").slice(0, 16);
+}
+//#endregion
+//#region src/vite/cache.ts
+/**
+* 开发服务器的编译缓存：编译结果存在磁盘上（Vite 的 cacheDir 下），重启后没改过的文件直接取用、不再编译。
+* Vite 自己只缓存依赖预构建，每次重启都要把首页用到的几百个模块重新编译一遍。
+*
+* 键包含一切会影响结果的东西：编译器代码（compilerCacheKey）、Babel 与官方插件的版本、选项、模块 id 与代码。
+* 每个模块一个文件，改了就覆盖，不会越积越多。读写失败都当作没有缓存。
+*/
+/** 影响编译结果的依赖包：版本变了缓存全部作废 */
+const COMPILER_PACKAGES = [
+	"@babel/core",
+	"@babel/plugin-transform-typescript",
+	"@vue/babel-plugin-jsx"
+];
+/** 磁盘上的编译缓存；salt 是选项等对所有模块都一样的部分 */
+var CompileCache = class {
+	dir;
+	salt;
+	constructor(cacheDir, salt) {
+		this.dir = join(cacheDir, "vue-tsx-pro");
+		const require = createRequire(import.meta.url);
+		const versions = COMPILER_PACKAGES.map((name) => require(`${name}/package.json`).version);
+		this.salt = [
+			compilerCacheKey(),
+			...versions,
+			salt
+		].join("\0");
+		mkdirSync(this.dir, { recursive: true });
+	}
+	/** 模块的缓存键 */
+	key(id, code) {
+		return createHash("sha1").update(this.salt).update("\0").update(id).update("\0").update(code).digest("hex");
+	}
+	/** 键对得上时返回缓存的结果 */
+	read(id, key) {
+		try {
+			const entry = JSON.parse(readFileSync(this.file(id), "utf8"));
+			return entry.key === key ? entry : void 0;
+		} catch {
+			return;
+		}
+	}
+	/** 写入（覆盖这个模块原来的缓存） */
+	write(id, key, result) {
+		try {
+			writeFileSync(this.file(id), JSON.stringify({
+				key,
+				...result
+			}));
+		} catch {}
+	}
+	file(id) {
+		return join(this.dir, `${createHash("sha1").update(id).digest("hex")}.json`);
+	}
+};
+//#endregion
+//#region src/vite/pool.ts
+/**
+* 编译线程池：冷启动、构建时几百个模块同时等编译，Babel 在主线程上只能一个个来。
+* 每个线程加载一份编译器（compile-worker.ts），请求按空闲分派；线程用到时才启动，最多 size 个。
+*/
+/** 编译线程的入口：仓库内按源码运行时是 .ts（Node 去掉类型），发布包里是构建出的 .js */
+const WORKER = new URL(import.meta.url.endsWith(".ts") ? "./compile-worker.ts" : "./compile-worker.js", import.meta.url);
+/** 编译线程池；设置要能在线程之间复制（见 module.ts） */
+var CompilePool = class {
+	setup;
+	size;
+	workers = [];
+	idle = [];
+	queue = [];
+	running = /* @__PURE__ */ new Map();
+	nextId = 0;
+	constructor(setup, size) {
+		this.setup = setup;
+		this.size = size;
+	}
+	/** 在某个线程里编译一个模块 */
+	run(request) {
+		return new Promise((resolve, reject) => {
+			this.queue.push({
+				request,
+				resolve,
+				reject
+			});
+			this.dispatch();
+		});
+	}
+	/**
+	* 先起 count 个线程（不超过上限）：线程启动时载入编译器（Babel 与各插件，约 1–2 秒），
+	* 开发服务器就绪后就在后台载入，浏览器第一次请求时不用再等
+	*/
+	warm(count) {
+		while (this.workers.length < Math.min(count, this.size)) this.idle.push(this.spawn());
+	}
+	/** 停掉全部线程（构建结束、服务器关闭） */
+	close() {
+		for (const worker of this.workers) worker.terminate();
+		this.workers = [];
+		this.idle = [];
+	}
+	dispatch() {
+		while (this.queue.length) {
+			const worker = this.idle.pop() ?? (this.workers.length < this.size ? this.spawn() : void 0);
+			if (!worker) return;
+			const job = this.queue.shift();
+			const id = this.nextId++;
+			this.running.set(id, {
+				...job,
+				worker
+			});
+			worker.postMessage({
+				id,
+				request: job.request
+			});
+		}
+	}
+	spawn() {
+		const worker = new Worker(WORKER, { workerData: this.setup });
+		worker.unref();
+		worker.on("message", ({ id, result, error }) => {
+			const job = this.running.get(id);
+			this.running.delete(id);
+			this.idle.push(worker);
+			if (error) job.reject(Object.assign(new Error(error.message), error));
+			else job.resolve(result ?? null);
+			this.dispatch();
+		});
+		worker.on("error", (error) => {
+			for (const [id, job] of this.running) {
+				if (job.worker !== worker) continue;
+				this.running.delete(id);
+				job.reject(error);
+			}
+			this.workers = this.workers.filter((item) => item !== worker);
+			this.idle = this.idle.filter((item) => item !== worker);
+			this.dispatch();
+		});
+		this.workers.push(worker);
+		return worker;
+	}
+};
+//#endregion
+//#region src/vite/workspace.ts
+/**
+* 仅供本仓库使用，发布包的使用方不需要：
+*   - 解析 @zerodep-dev/vue-tsx-pro-* 时直接读源码（exports 里的 @vue-tsx-pro/source 条件），改了组件库不用先构建
+*   - 开发服务器与测试里，包入口（桶文件）的具名导入改成直接导入所在模块：
+*     `import { Button } from '@zerodep-dev/vue-tsx-pro-ui'` → `import { Button } from '<ui>/src/base/Button.tsx'`。
+*     经过桶文件导入时，组件库里不是组件的模块（样式、状态、工具函数、主题、工厂函数做的组件）改了，
+*     热更新沿着桶文件 → main.ts 一路走到没人接受更新的地方，整页刷新；直接导入时停在用到它的组件上。
+*     构建时不改：lazyBarrel 本来就只编译用到的再导出。
+*   - 按源码读的包，它自己导入的第三方依赖一开始就预构建（包在 package.json 的 vueTsxPro.optimizeDeps 里声明）
+*/
+/** 解析出顶层语句；有语法错误时为 undefined */
+function statements(filename, code) {
+	const result = parseSync(filename, code);
+	return result.errors.length ? void 0 : result.program.body;
+}
+/** 解析 @zerodep-dev/vue-tsx-pro-* 用源码；开发与测试时桶文件的具名导入改成直接导入（见文件开头） */
+function workspaceSource() {
+	const condition = "@vue-tsx-pro/source";
+	let serve = false;
+	/** 解析后的包入口 → 桶文件（不是纯粹的再导出时为 null）；入口文件改了重新读 */
+	const barrels = /* @__PURE__ */ new Map();
+	return {
+		name: "vue-tsx-pro:workspace-source",
+		config(user) {
+			return {
+				resolve: { conditions: [
+					condition,
+					"module",
+					"browser",
+					"development|production"
+				] },
+				optimizeDeps: sourceDependencies(user.root ?? process.cwd()),
+				ssr: { resolve: { conditions: [
+					condition,
+					"module",
+					"node",
+					"development|production"
+				] } }
+			};
+		},
+		configResolved(config) {
+			serve = config.command === "serve";
+		},
+		watchChange(id, change) {
+			if (change.event === "update") barrels.delete(normalizePath(id));
+			else barrels.clear();
+		},
+		transform: {
+			filter: {
+				id: {
+					include: /\.(?:[cm]?[jt]sx?|vue)(?:\?|$)/,
+					exclude: /\/node_modules\//
+				},
+				code: "@zerodep-dev/vue-tsx-pro-"
+			},
+			handler(code, id) {
+				if (!serve || id.startsWith("\0")) return;
+				return directImports(this, code, id, barrels);
+			}
+		}
+	};
+}
+/** 把模块里从桶文件的具名导入改成直接导入；没有可改的时返回 undefined */
+async function directImports(context, code, id, barrels) {
+	const body = statements("module.ts", code);
+	if (!body) return void 0;
+	const edits = [];
+	for (const node of body) {
+		if (node.type !== "ImportDeclaration" || node.importKind === "type") continue;
+		const source = node.source.value;
+		if (!source.startsWith("@zerodep-dev/vue-tsx-pro-") || !node.specifiers.length) continue;
+		if (!node.specifiers.every((specifier) => specifier.type === "ImportSpecifier")) continue;
+		const resolved = await context.resolve(source, id);
+		if (!resolved || resolved.external) continue;
+		const barrel = await barrelOf(context, resolved.id, barrels);
+		if (!barrel) continue;
+		const byFile = /* @__PURE__ */ new Map();
+		const rest = [];
+		for (const specifier of node.specifiers) {
+			if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") continue;
+			const local = specifier.local.name;
+			const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : void 0;
+			const target = imported === void 0 ? void 0 : barrel.exports.get(imported);
+			if (!target) {
+				rest.push(code.slice(specifier.start, specifier.end));
+				continue;
+			}
+			const names = byFile.get(target.file) ?? [];
+			names.push(target.name === local ? local : `${target.name} as ${local}`);
+			byFile.set(target.file, names);
+		}
+		const statements = [
+			...barrel.sideEffects.map((file) => `import ${JSON.stringify(file)};`),
+			...[...byFile].map(([file, names]) => `import { ${names.join(", ")} } from ${JSON.stringify(file)};`),
+			...rest.length ? [`import { ${rest.join(", ")} } from ${JSON.stringify(source)};`] : []
+		];
+		const lines = code.slice(node.start, node.end).split("\n").length - 1;
+		edits.push({
+			start: node.start,
+			end: node.end,
+			text: statements.join(" ") + "\n".repeat(lines)
+		});
+	}
+	if (!edits.length) return void 0;
+	let next = code;
+	for (const edit of edits.reverse()) next = next.slice(0, edit.start) + edit.text + next.slice(edit.end);
+	return {
+		code: next,
+		map: null
+	};
+}
+function barrelOf(context, id, barrels) {
+	let barrel = barrels.get(id);
+	if (!barrel) {
+		barrel = readBarrel(context, id);
+		barrels.set(id, barrel);
+	}
+	return barrel;
+}
+/**
+* 读入口文件：只有从本包相对路径的再导出（`export { … } from './x'`）与副作用导入时才算桶文件；
+* 有自己的声明、`export *`、从别的包再导出时返回 null，不改写
+*/
+async function readBarrel(context, id) {
+	const file = id.split("?")[0];
+	let body;
+	try {
+		body = statements(file, readFileSync(file, "utf8"));
+	} catch {
+		return null;
+	}
+	if (!body) return null;
+	const barrel = {
+		exports: /* @__PURE__ */ new Map(),
+		sideEffects: []
+	};
+	const resolve = async (source) => {
+		if (!source.startsWith(".")) return void 0;
+		const resolved = await context.resolve(source, id);
+		return resolved && !resolved.external ? resolved.id : void 0;
+	};
+	for (const node of body) {
+		if (node.type === "ImportDeclaration" && !node.specifiers.length) {
+			const file = await resolve(node.source.value);
+			if (!file) return null;
+			barrel.sideEffects.push(file);
+			continue;
+		}
+		if (node.type !== "ExportNamedDeclaration" || !node.source || node.declaration) return null;
+		if (node.exportKind === "type") continue;
+		const file = await resolve(node.source.value);
+		if (!file) return null;
+		for (const specifier of node.specifiers) {
+			if (specifier.exportKind === "type") continue;
+			if (specifier.local.type !== "Identifier" || specifier.exported.type !== "Identifier") return null;
+			barrel.exports.set(specifier.exported.name, {
+				file,
+				name: specifier.local.name
+			});
+		}
+	}
+	return barrel;
+}
+/**
+* 按源码读的 @zerodep-dev/vue-tsx-pro-* 包自己导入的第三方依赖：不声明的话 Vite 要等页面（或浏览器测试）用到才发现，
+* 发现时重新预构建、刷新页面，正在初始化的测试页会卡住。写成“包 > 依赖”，从包的目录解析，应用不必自己安装；
+* 没装的可选依赖（three、@unovis/ts 等）跳过，免得 Vite 报解析不到
+*/
+function sourceDependencies(root) {
+	const include = [];
+	const exclude = [];
+	const own = readManifest(join(root, "package.json"));
+	if (!own) return {
+		include,
+		exclude
+	};
+	const require = createRequire(join(root, "package.json"));
+	for (const name of Object.keys({
+		...own.dependencies,
+		...own.devDependencies
+	})) {
+		if (!name.startsWith("@zerodep-dev/vue-tsx-pro-")) continue;
+		let manifest;
+		try {
+			manifest = require.resolve(`${name}/package.json`);
+		} catch {
+			continue;
+		}
+		const declared = readManifest(manifest)?.vueTsxPro?.optimizeDeps;
+		for (const dependency of declared?.include ?? []) if (installed(packageName(dependency), dirname(manifest))) include.push(`${name} > ${dependency}`);
+		exclude.push(...declared?.exclude ?? []);
+	}
+	return {
+		include,
+		exclude
+	};
+}
+/** 导入说法里的包名：'zod/v4/core' → 'zod'，'@lucide/icons/x' → '@lucide/icons' */
+function packageName(specifier) {
+	const parts = specifier.split("/");
+	return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+/** 从某个目录往上找得到这个包（Node 的解析方式；不经 exports，只看装没装） */
+function installed(name, from) {
+	for (let directory = from;; directory = dirname(directory)) {
+		if (existsSync(join(directory, "node_modules", name, "package.json"))) return true;
+		if (dirname(directory) === directory) return false;
+	}
+}
+function readManifest(path) {
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/vite/index.ts
+/** Vite 预设：`plugins: [vueTsxPro()]` */
+function vueTsxPro(options = {}) {
+	return [compiler(options)];
+}
+/** 脚本模块：JS、TS 文件，或 Vue 单文件组件里的脚本（…/X.vue?vue&type=script&lang.tsx） */
+const SCRIPT = /\.[cm]?[jt]sx?(?:\?|$)/;
+const SCRIPT_FILE = /\.[cm]?[jt]sx?$/;
+/** 编译插件：每个文件一次 compile，加上组件的热更新、SSR 登记 */
+function compiler(options) {
+	const optimize = options.optimize ?? true;
+	let setup;
+	let cache;
+	let pool;
+	let cacheDir = "";
+	const run = async (request) => pool ? pool.run(request) : (await import("./module--rQ2-rvm.js").then((n) => n.n)).compileModule(request, setup);
+	return {
+		name: "vue-tsx-pro",
+		enforce: "pre",
+		configureVitest({ defineCacheKeyGenerator }) {
+			defineCacheKeyGenerator?.(({ sourceCode }) => sourceCode.includes("import.meta.glob") ? false : `${compilerCacheKey()}${optimize ? "" : ":plain"}`);
+		},
+		config(user) {
+			const flag = (name, fallback) => {
+				const value = user.define?.[name];
+				if (value === void 0) return fallback;
+				try {
+					return typeof value === "string" ? JSON.parse(value) : value;
+				} catch {
+					return value;
+				}
+			};
+			return {
+				oxc: { include: /\.[cm]?ts$/ },
+				define: {
+					__VUE_OPTIONS_API__: flag("__VUE_OPTIONS_API__", true),
+					__VUE_PROD_DEVTOOLS__: flag("__VUE_PROD_DEVTOOLS__", false),
+					__VUE_PROD_HYDRATION_MISMATCH_DETAILS__: flag("__VUE_PROD_HYDRATION_MISMATCH_DETAILS__", false)
+				},
+				optimizeDeps: { rolldownOptions: { transform: { jsx: "preserve" } } }
+			};
+		},
+		configResolved(config) {
+			cacheDir = `${normalizePath(config.cacheDir)}/`;
+			const hmr = config.command === "serve" && !config.isProduction;
+			setup = {
+				optimize,
+				root: config.root,
+				jsx: options.jsx,
+				hmr
+			};
+			if ((options.cache ?? true) && config.command === "serve" && !process.env.VITEST) cache = new CompileCache(config.cacheDir, JSON.stringify([
+				options,
+				hmr,
+				process.env.NODE_ENV
+			]));
+			if ((options.parallel ?? true) && !process.env.VITEST && cloneable(setup)) pool = new CompilePool(setup, Math.max(1, Math.min(availableParallelism() - 1, 6)));
+		},
+		configureServer() {
+			pool?.warm(2);
+		},
+		closeBundle() {
+			pool?.close();
+		},
+		resolveId: (id) => id === "/__vue-jsx-ssr-register-helper" ? id : void 0,
+		load: (id) => id === "/__vue-jsx-ssr-register-helper" ? SSR_REGISTER_CODE : void 0,
+		transform: {
+			filter: { id: SCRIPT },
+			async handler(code, id, transformOptions) {
+				if (id.startsWith("\0")) return;
+				const [file = id, query = ""] = id.split("?");
+				if (/(?:^|&)(?:raw|url)(?:&|$)/.test(query)) return;
+				const own = SCRIPT_FILE.test(file) && !file.includes("/node_modules/") && !file.startsWith(cacheDir);
+				const lang = languageOf(id);
+				if (!lang) return;
+				const ssr = transformOptions?.ssr === true;
+				const key = cache?.key(ssr ? `${id}\0ssr` : id, code);
+				const cached = key ? cache.read(ssr ? `${id}\0ssr` : id, key) : void 0;
+				if (cached) {
+					for (const warning of cached.warnings) this.warn(warning);
+					return {
+						code: cached.code,
+						map: cached.map
+					};
+				}
+				const result = await run({
+					code,
+					id,
+					file,
+					lang,
+					own,
+					ssr
+				});
+				if (!result) return;
+				for (const warning of result.warnings) this.warn(warning);
+				if (key) cache.write(ssr ? `${id}\0ssr` : id, key, result);
+				return {
+					code: result.code,
+					map: result.map
+				};
+			}
+		}
+	};
+}
+/** 设置能不能复制到编译线程（含函数的选项不能） */
+function cloneable(value) {
+	try {
+		structuredClone(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { vueTsxPro, workspaceSource };

package/package.json

@@ -1,6 +1,101 @@
 {
   "name": "@zerodep-dev/vue-tsx-pro-tsx",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "更自然的 Vue TSX：组件边界、符文编译与 Vite 预设",
+  "type": "module",
+  "license": "MIT",
+  "author": "kenconnet666",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kenconnet666/vue-tsx-pro.git",
+    "directory": "packages/tsx"
+  },
+  "homepage": "https://github.com/kenconnet666/vue-tsx-pro#readme",
+  "bugs": {
+    "url": "https://github.com/kenconnet666/vue-tsx-pro/issues"
+  },
+  "keywords": [
+    "vue",
+    "tsx",
+    "jsx",
+    "runes",
+    "css-in-js",
+    "stylex",
+    "vite-plugin"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "exports": {
+    ".": {
+      "@vue-tsx-pro/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./vite": {
+      "@vue-tsx-pro/source": "./src/vite/index.ts",
+      "types": "./dist/vite.d.ts",
+      "default": "./dist/vite.js"
+    },
+    "./styles": {
+      "@vue-tsx-pro/source": "./src/styles/index.ts",
+      "types": "./dist/styles.d.ts",
+      "default": "./dist/styles.js"
+    },
+    "./compiler": {
+      "@vue-tsx-pro/source": "./src/compiler/index.ts",
+      "types": "./dist/compiler.d.ts",
+      "default": "./dist/compiler.js"
+    },
+    "./jsx-runtime": {
+      "types": "./types/jsx-runtime.d.ts"
+    },
+    "./runes": {
+      "types": "./types/runes.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "types"
+  ],
+  "dependencies": {
+    "@babel/core": "8.0.7",
+    "@babel/plugin-transform-typescript": "8.0.6",
+    "@vue/babel-plugin-jsx": "3.0.0",
+    "@vue/devtools-api": "8.2.1"
+  },
+  "peerDependencies": {
+    "vite": "^8.0.0",
+    "vue": "^3.5.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "happy-dom": "21.0.3",
+    "tsdown": "0.23.1",
+    "typescript": "7.1.0-beta",
+    "vite": "8.3.4",
+    "vitest": "5.0.5",
+    "vue": "3.5.44"
+  },
+  "vueTsxPro": {
+    "optimizeDeps": {
+      "include": [
+        "@vue/devtools-api"
+      ]
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p . --incremental --tsBuildInfoFile node_modules/.cache/typecheck.tsbuildinfo",
+    "test": "vitest run --configLoader native"
+  }
 }