@abinnovision/payloadcms-mcpx 1.1.0-beta.3 → 1.1.0-beta.6

package/README.md

@@ -170,16 +170,17 @@ every `collection` and `global` enum contains only the slugs the key may touch.
 Builtin tools reject unknown arguments by name instead of silently ignoring
 them.
 
-| Tool               | Purpose                                                                  | Key arguments                                                                                |
-| ------------------ | ------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
-| `listCapabilities` | What this key may do, `create` apart from `write`; call first to orient. | none                                                                                         |
-| `describeSchema`   | Field shape of one node; `next` lists the drill-down paths.              | `collection` \| `global`, `paths?`, `expand?`                                                |
-| `findDocuments`    | Query documents.                                                         | `collection`, `where?`, `sort?`, `limit?`, `page?`, `depth?`, `select?`, `locale?`, `draft?` |
-| `getDocument`      | Read one document or a subtree of it.                                    | `collection` + `id` \| `global`, `path?`, `depth?`, `locale?`, `draft?`, `outline?`          |
-| `patchDocument`    | Apply RFC 6902 operations to the current draft.                          | `collection` + `id` \| `global`, `locale`, `patches`, `expectedUpdatedAt?`                   |
-| `createDocument`   | Create a draft from a minimal seed. Not for upload collections.          | `collection`, `locale`, `data`                                                               |
-| `validateDocument` | Publish blockers without saving anything.                                | `collection` + `id` \| `global`, `locale`                                                    |
-| `publishDocument`  | Publish the current draft.                                               | `collection` + `id` \| `global`, `expectedUpdatedAt?`                                        |
+| Tool               | Purpose                                                                  | Key arguments                                                                                                  |
+| ------------------ | ------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
+| `listCapabilities` | What this key may do, `create` apart from `write`; call first to orient. | none                                                                                                           |
+| `describeSchema`   | Field shape of one node; `next` lists the drill-down paths.              | `collection` \| `global`, `paths?`, `expand?`                                                                  |
+| `findDocuments`    | Query documents.                                                         | `collection`, `where?`, `sort?`, `limit?`, `page?`, `depth?`, `select?`, `locale?`, `draft?`                   |
+| `getDocument`      | Read one document or a subtree of it, an old version, or a diff.         | `collection` + `id` \| `global`, `path?`, `depth?`, `locale?`, `draft?`, `outline?`, `versionId?`, `diffFrom?` |
+| `findVersions`     | Version history of one document or global, metadata only.                | `collection` + `id` \| `global`, `limit?`, `page?`, `status?`, `locale?`                                       |
+| `patchDocument`    | Apply RFC 6902 operations to the current draft.                          | `collection` + `id` \| `global`, `locale`, `patches`, `expectedUpdatedAt?`                                     |
+| `createDocument`   | Create a draft from a minimal seed. Not for upload collections.          | `collection`, `locale`, `data`                                                                                 |
+| `validateDocument` | Publish blockers without saving anything.                                | `collection` + `id` \| `global`, `locale`                                                                      |
+| `publishDocument`  | Publish the current draft.                                               | `collection` + `id` \| `global`, `expectedUpdatedAt?`                                                          |
 
 ### Paths and pointers
 
@@ -416,6 +417,27 @@ privileged, so blocker paths and messages may name fields the key's user cannot
 read, though values are never included. `validateDocument` runs the same
 traversal without saving anything, which is why it carries no `readOnlyHint`.
 
+## Version history
+
+On a collection or global with `versions` (with or without drafts),
+`findVersions` lists the history newest first: `versionId`, timestamps,
+`status`, `latest` and `autosave`, but no bodies. It is a read, so it follows
+the `read` capability. The document's own `read` access is checked first, then
+Payload's `readVersions`.
+
+`getDocument` takes `versionId` to read one of those versions in place of the
+document, with `path`, `outline`, `locale` and `depth` working as usual. With
+`diffFrom`, a `versionId` or `"published"` (the newest version with published
+status, in any locale), it returns `{ from, to, patch }`: the RFC 6902
+operations that turn `diffFrom` into the document read (the current draft, or
+`versionId` when given). The ops use the pointers `patchDocument` takes, `path`
+limits them to a subtree, and `id`, timestamps and `_status` are left out. Arrays diff by position, so a reordered block shows up as replaces.
+
+There is no restore tool. To revert, pass the old version as `versionId` and the
+latest one as `diffFrom`, then apply the patch with `patchDocument`. The revert
+lands as a draft like any other write, with `expectedUpdatedAt` and publish
+blockers in force.
+
 ## Custom tools
 
 ```ts

package/dist/options.mjs

@@ -66,6 +66,7 @@ const normalizeCollections = (config, options, apiKeysSlug) => {
 			read: settings.read ?? true,
 			write: normalizeWriteMode("Collection", slug, settings.write),
 			hasDrafts,
+			hasVersions: Boolean(collection.versions),
 			isUpload: Boolean(collection.upload),
 			fieldName: toCamelCase(slug)
 		};
@@ -90,6 +91,7 @@ const normalizeGlobals = (config, options) => {
 			read: settings.read ?? true,
 			write: normalizeWriteMode("Global", slug, settings.write),
 			hasDrafts,
+			hasVersions: Boolean(global.versions),
 			isUpload: false,
 			fieldName: toCamelCase(slug)
 		};

package/dist/tools/builtin.mjs

@@ -1,6 +1,7 @@
 import { createDocument } from "./create-document.mjs";
 import { describeSchema } from "./describe-schema.mjs";
 import { findDocuments } from "./find-documents.mjs";
+import { findVersions } from "./find-versions.mjs";
 import { getDocument } from "./get-document.mjs";
 import { listCapabilities } from "./list-capabilities.mjs";
 import { patchDocument } from "./patch-document.mjs";
@@ -17,6 +18,7 @@ import { validateDocument } from "./validate-document.mjs";
 	describeSchema,
 	findDocuments,
 	getDocument,
+	findVersions,
 	patchDocument,
 	createDocument,
 	validateDocument,

package/dist/tools/find-versions.mjs

@@ -0,0 +1,70 @@
+import { jsonResult } from "../result.mjs";
+import { idShape, localeOf, localeShape, slugsFor, targetShape } from "./shared.mjs";
+import { requireIdFor, resolveTarget } from "./target.mjs";
+import { defineMcpxTool } from "../types.mjs";
+import { queryVersions } from "./versions.mjs";
+import { z } from "zod";
+/**
+* Bodies are left out so a long history stays small; `getDocument` reads one
+* when it is needed. The document's `read` access is checked first, then
+* Payload's `readVersions`.
+*/ const findVersions = defineMcpxTool({
+	name: "findVersions",
+	description: `Lists the version history of one document or global, newest first. Returns metadata only; read a version's body with getDocument and "versionId", or what changed with "diffFrom".
+
+Pass exactly one of "collection" and "global". "id" is required with "collection" and must be omitted with "global". Autosave versions are listed too, marked "autosave".`,
+	annotations: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
+	isEnabled: (scope) => {
+		const { collections, globals } = slugsFor(scope, "versions");
+		return collections.length + globals.length > 0;
+	},
+	inputSchema: (scope) => ({
+		...targetShape(scope, "versions", {
+			collection: "Collection holding the document.",
+			global: "Global whose history to list."
+		}),
+		...idShape(scope, "versions"),
+		limit: z.number().int().min(1).max(scope.limits.maxLimit).optional().describe(`Versions per page. Default 10, at most ${String(scope.limits.maxLimit)}.`),
+		page: z.number().int().min(1).optional().describe("Page number, from 1."),
+		status: z.enum(["published", "draft"]).optional().describe("Only versions with this status."),
+		...localeShape(scope, {
+			required: false,
+			description: "Locale whose status to report. Defaults to the default locale."
+		})
+	}),
+	handler: async ({ args, scope }) => {
+		const target = resolveTarget(scope, args, "versions");
+		const id = requireIdFor(target, args.id);
+		const result = await queryVersions(scope, {
+			target,
+			id,
+			depth: 0,
+			locale: localeOf(scope, args.locale)
+		}, {
+			limit: args.limit ?? 10,
+			...args.page === void 0 ? {} : { page: args.page },
+			...args.status === void 0 ? {} : { status: args.status }
+		});
+		const versions = result.docs.map((doc) => ({
+			versionId: doc.id,
+			createdAt: doc["createdAt"],
+			updatedAt: doc["updatedAt"],
+			status: doc.version["_status"] ?? null,
+			latest: doc["latest"] === true,
+			autosave: doc["autosave"] === true,
+			...doc["publishedLocale"] ? { publishedLocale: doc["publishedLocale"] } : {}
+		}));
+		return jsonResult({
+			versions,
+			totalDocs: result.totalDocs,
+			page: result.page,
+			totalPages: result.totalPages,
+			hasNextPage: result.hasNextPage
+		});
+	}
+});
+//#endregion
+export { findVersions };

package/dist/tools/get-document.mjs

@@ -3,24 +3,46 @@ import { JSON_POINTER_PATTERN, findRichTextField, splitPath } from "../schema/wa
 import { lexicalOutline } from "../schema/outline.mjs";
 import { resolveDataPointer } from "../schema/pointer.mjs";
 import "../schema/index.mjs";
-import { depthShape, idShape, localeOf, localeShape, targetShape } from "./shared.mjs";
+import { depthShape, idSchema, idShape, localeOf, localeShape, slugsFor, targetShape } from "./shared.mjs";
 import { refOf, requireIdFor, resolveTarget } from "./target.mjs";
 import { defineMcpxTool } from "../types.mjs";
+import { diffDocuments, loadPublished, loadVersion, readLive } from "./versions.mjs";
+import { APIError } from "payload";
 import { z } from "zod";
 import { Pointer } from "rfc6902";
 //#region src/tools/get-document.ts
 const OUTLINE_ERROR = "\"outline\" applies to a rich text field; give \"path\" for one.";
+const DESCRIPTION = `Reads one document, or one subtree of it when "path" is given as a JSON pointer such as "/layout/sections/2". Returns the latest draft by default. Read before patching: the response carries "updatedAt" for expectedUpdatedAt and the indices pointers need.
+
+Pass exactly one of "collection" and "global". "id" is required with "collection" and must be omitted with "global", because a global is a singleton.
+
+Set "outline" on a rich text "path" to get a compact positional listing of its nodes instead of the raw editor state.
+
+On an entity with versions, "versionId" (from findVersions) reads that version instead. "diffFrom" returns the RFC 6902 operations turning a version, or "published" (the newest version with published status, regardless of locale), into the document read, in the pointer syntax patchDocument takes and limited to "path" when given. To revert, pass the old version as "versionId" and the latest one from findVersions as "diffFrom", then apply the patch with patchDocument.`;
+/** Refuses `versionId` and `diffFrom` where they cannot apply. */ const assertVersionArgs = (scope, target, args) => {
+	if (args.versionId === void 0 && args.diffFrom === void 0) return;
+	const { collections, globals } = slugsFor(scope, "versions");
+	if (!(target.kind === "collection" ? collections : globals).includes(target.slug)) throw new APIError(`"${target.slug}" keeps no versions.`, 400);
+	if (args.versionId !== void 0 && args.draft !== void 0) throw new APIError("Pass either \"versionId\" or \"draft\", not both.", 400);
+	if (args.diffFrom !== void 0 && args.outline) throw new APIError("\"outline\" cannot be combined with \"diffFrom\".", 400);
+};
+const diffResult = async (scope, read, diff, doc) => {
+	const from = diff.from === "published" ? await loadPublished(scope, read) : await loadVersion(scope, read, diff.from);
+	if (!from) return errorResult(diff.from === "published" ? `"${read.target.slug}" has no published version to diff from.` : `Version "${String(diff.from)}" not found.`);
+	return jsonResult({
+		from: from.id,
+		to: diff.to ?? "current",
+		...diff.pointer === void 0 ? {} : { path: diff.pointer.toString() },
+		patch: diffDocuments(from.version, doc, diff.pointer)
+	});
+};
 /**
 * With `path` the handler returns the subtree plus the `id`, `_status` and
 * `updatedAt` a client needs to write back, so a caller reading one branch
 * still gets the timestamp `expectedUpdatedAt` wants without a second call.
 */ const getDocument = defineMcpxTool({
 	name: "getDocument",
-	description: `Reads one document, or one subtree of it when "path" is given as a JSON pointer such as "/layout/sections/2". Returns the latest draft by default. Read before patching: the response carries "updatedAt" for expectedUpdatedAt and the indices pointers need.
-
-Pass exactly one of "collection" and "global". "id" is required with "collection" and must be omitted with "global", because a global is a singleton.
-
-Set "outline" on a rich text "path" to get a compact positional listing of its nodes instead of the raw editor state.`,
+	description: DESCRIPTION,
 	annotations: {
 		readOnlyHint: true,
 		openWorldHint: false
@@ -39,42 +61,44 @@ Set "outline" on a rich text "path" to get a compact positional listing of its n
 			description: "Locale to read. Defaults to the default locale."
 		}),
 		draft: z.boolean().optional().describe("Return the latest draft. Default true."),
-		outline: z.boolean().optional().describe("For a rich text field, return a compact positional outline instead of the editor state. Requires \"path\".")
+		outline: z.boolean().optional().describe("For a rich text field, return a compact positional outline instead of the editor state. Requires \"path\"."),
+		versionId: idSchema.optional().describe("Version to read instead of the document, from findVersions. Only for entities with versions; not with \"draft\"."),
+		diffFrom: idSchema.optional().describe("Version id, or \"published\" for the newest published version in any locale, to diff from. Returns {from, to, patch} instead of the document. Only for entities with versions.")
 	}),
 	handler: async ({ args, scope }) => {
 		const target = resolveTarget(scope, args, "read");
 		const id = requireIdFor(target, args.id);
-		const locale = localeOf(scope, args.locale);
-		const shared = {
+		assertVersionArgs(scope, target, args);
+		let pointer;
+		try {
+			pointer = args.path ? Pointer.fromJSON(args.path) : void 0;
+		} catch {
+			return errorResult(`"${String(args.path)}" is not a valid JSON pointer.`);
+		}
+		const read = {
+			target,
+			id,
 			depth: args.depth ?? 0,
-			draft: args.draft ?? true,
-			overrideAccess: false,
-			req: scope.req,
-			...locale === void 0 ? {} : { locale }
+			locale: localeOf(scope, args.locale)
 		};
-		const doc = await (target.kind === "collection" ? scope.req.payload.findByID({
-			...shared,
-			collection: target.slug,
-			id
-		}) : scope.req.payload.findGlobal({
-			...shared,
-			slug: target.slug
-		}));
-		if (args.path === void 0 || args.path === "") {
+		const doc = args.versionId === void 0 ? await readLive(scope, read, { draft: args.draft ?? true }) : (await loadVersion(scope, read, args.versionId))?.version;
+		if (!doc) return errorResult(`Version "${String(args.versionId)}" not found.`);
+		if (args.diffFrom !== void 0) return await diffResult(scope, read, {
+			from: args.diffFrom,
+			to: args.versionId,
+			pointer
+		}, doc);
+		if (pointer === void 0) {
 			if (args.outline) return errorResult(OUTLINE_ERROR);
 			return jsonResult(doc);
 		}
-		let value;
-		try {
-			value = Pointer.fromJSON(args.path).get(doc);
-		} catch {
-			return errorResult(`"${args.path}" is not a valid JSON pointer.`);
-		}
+		const path = pointer.toString();
+		const value = pointer.get(doc);
 		const envelope = {
-			...target.kind === "collection" ? { id: doc["id"] } : { global: target.slug },
+			...target.kind === "collection" ? { id } : { global: target.slug },
 			status: doc["_status"],
 			updatedAt: doc["updatedAt"],
-			path: args.path
+			path
 		};
 		if (!args.outline) return jsonResult({
 			...envelope,
@@ -84,7 +108,7 @@ Set "outline" on a rich text "path" to get a compact positional listing of its n
 		try {
 			resolution = resolveDataPointer(scope.req.payload.config, {
 				doc,
-				pointer: args.path,
+				pointer: path,
 				ref: refOf(target)
 			});
 		} catch (error) {
@@ -94,7 +118,7 @@ Set "outline" on a rich text "path" to get a compact positional listing of its n
 		if (!field) return errorResult(OUTLINE_ERROR);
 		return jsonResult({
 			...envelope,
-			outline: lexicalOutline(value, args.path, field)
+			outline: lexicalOutline(value, path, field)
 		});
 	}
 });

package/dist/tools/list-capabilities.mjs

@@ -42,6 +42,7 @@ A global is a singleton: it has no id, is not listed by findDocuments and cannot
 				create: capability.write && canCreate(entry),
 				publish: capability.publish,
 				drafts: entry.hasDrafts,
+				versions: entry.hasVersions,
 				draftValidation: hasDraftValidationEnabled(config),
 				idType: collection.customIDType ?? payload.db.defaultIDType
 			}];
@@ -59,6 +60,7 @@ A global is a singleton: it has no id, is not listed by findDocuments and cannot
 				write: capability.write,
 				publish: capability.publish,
 				drafts: entry.hasDrafts,
+				versions: entry.hasVersions,
 				draftValidation: hasDraftValidationEnabled(config)
 			}];
 		});

package/dist/tools/names.mjs

@@ -6,6 +6,7 @@
 	"describeSchema",
 	"findDocuments",
 	"getDocument",
+	"findVersions",
 	"patchDocument",
 	"createDocument",
 	"validateDocument",

package/dist/tools/shared.mjs

@@ -60,6 +60,16 @@ const slugsWhere = (scope, predicate, allowed) => {
 			collections: scope.readable,
 			globals: scope.readableGlobals
 		};
+		case "versions": return {
+			collections: slugsWhere(scope, (entity) => entity.hasVersions, {
+				collections: scope.readable,
+				globals: []
+			}),
+			globals: slugsWhere(scope, (entity) => entity.hasVersions, {
+				collections: [],
+				globals: scope.readableGlobals
+			})
+		};
 		case "write": return {
 			collections: scope.writable,
 			globals: scope.writableGlobals

package/dist/tools/versions.mjs

@@ -0,0 +1,119 @@
+import { Pointer, createPatch } from "rfc6902";
+//#region src/tools/versions.ts
+/** Bookkeeping that differs between saves without saying anything about content. */ const NOISE = [
+	"id",
+	"globalType",
+	"createdAt",
+	"updatedAt",
+	"_status"
+];
+/** Newest first, with the id breaking ties between saves in the same instant. */ const NEWEST_FIRST = ["-updatedAt", "-id"];
+/** The document or global as the key's user sees it. */ const readLive = async (scope, read, options) => {
+	const shared = {
+		depth: read.depth,
+		draft: options.draft,
+		overrideAccess: false,
+		req: scope.req,
+		...options.select === void 0 ? {} : { select: options.select },
+		...read.locale === void 0 ? {} : { locale: read.locale }
+	};
+	return await (read.target.kind === "collection" ? scope.req.payload.findByID({
+		...shared,
+		collection: read.target.slug,
+		id: read.id
+	}) : scope.req.payload.findGlobal({
+		...shared,
+		slug: read.target.slug
+	}));
+};
+/**
+* Payload checks only `readVersions` on a version read, never `read`, so the
+* document itself is read first and throws when the key's user may not see it.
+*/ const assertReadable = async (scope, read) => {
+	await readLive(scope, {
+		...read,
+		depth: 0
+	}, {
+		draft: true,
+		select: {}
+	});
+};
+/** `parent` comes back as a raw id or, populated, as the document itself. */ const isVersionOf = (version, id) => {
+	const parent = version["parent"];
+	const parentId = typeof parent === "object" && parent !== null ? parent["id"] : parent;
+	return (typeof parentId === "string" || typeof parentId === "number") && String(parentId) === String(id);
+};
+/**
+* Reads one version, or `null` when it does not exist, is not readable, or
+* belongs to another document. `findVersionByID` knows nothing of the document
+* the caller asked about, so the parent check is what keeps one readable
+* document from opening the history of another.
+*/ const loadVersion = async (scope, read, versionId) => {
+	await assertReadable(scope, read);
+	const { payload } = scope.req;
+	const shared = {
+		id: versionId,
+		depth: read.depth,
+		disableErrors: true,
+		overrideAccess: false,
+		req: scope.req,
+		...read.locale === void 0 ? {} : { locale: read.locale }
+	};
+	const version = await (read.target.kind === "collection" ? payload.findVersionByID({
+		...shared,
+		collection: read.target.slug
+	}) : payload.findGlobalVersionByID({
+		...shared,
+		slug: read.target.slug
+	}));
+	if (!version) return null;
+	if (read.id !== void 0 && !isVersionOf(version, read.id)) return null;
+	return version;
+};
+/** One page of a document's or global's history, newest first. */ const queryVersions = async (scope, read, options) => {
+	await assertReadable(scope, read);
+	const where = {
+		...read.id === void 0 ? {} : { parent: { equals: read.id } },
+		...options.status === void 0 ? {} : { "version._status": { equals: options.status } }
+	};
+	const shared = {
+		depth: read.depth,
+		limit: options.limit,
+		sort: NEWEST_FIRST,
+		overrideAccess: false,
+		req: scope.req,
+		where,
+		...options.page === void 0 ? {} : { page: options.page },
+		...read.locale === void 0 ? {} : { locale: read.locale }
+	};
+	return await (read.target.kind === "collection" ? scope.req.payload.findVersions({
+		...shared,
+		collection: read.target.slug
+	}) : scope.req.payload.findGlobalVersions({
+		...shared,
+		slug: read.target.slug
+	}));
+};
+/** The newest version whose status is published, or `null` if none is. */ const loadPublished = async (scope, read) => {
+	return (await queryVersions(scope, read, {
+		status: "published",
+		limit: 1
+	})).docs[0] ?? null;
+};
+const strip = (doc) => Object.fromEntries(Object.entries(doc).filter(([key]) => !NOISE.includes(key)));
+/**
+* The RFC 6902 operations turning `from` into `to`, limited to the subtree at
+* `pointer`. Op paths stay absolute, so they apply as `patchDocument` ops.
+*/ const diffDocuments = (from, to, pointer = Pointer.fromJSON("")) => {
+	const wrap = (doc) => {
+		const value = pointer.get(strip(doc));
+		return value === void 0 ? {} : { value };
+	};
+	const path = pointer.toString();
+	return createPatch(wrap(from), wrap(to)).map((op) => ({
+		...op,
+		path: `${path}${op.path.slice(6)}`
+	}));
+};
+//#endregion
+export { diffDocuments, isVersionOf, loadPublished, loadVersion, queryVersions, readLive };

package/dist/types.d.mts

@@ -50,6 +50,8 @@ export interface McpxExposedEntity {
   read: boolean;
   write: McpxWriteMode;
   hasDrafts: boolean;
+  /** Payload keeps a version history, with or without drafts. */
+  hasVersions: boolean;
   /** An upload document is a file, and no tool here can supply one. */
   isUpload: boolean;
   /** Name of the capability group on the key document. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@abinnovision/payloadcms-mcpx",
-  "version": "1.1.0-beta.3",
+  "version": "1.1.0-beta.6",
   "description": "Payload CMS plugin exposing a fixed, schema-aware MCP tool surface with draft-only writes and per-API-key capabilities.",
   "keywords": [
     "payload",
@@ -59,25 +59,25 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
     "rfc6902": "^5.3.0",
-    "zod": "^4.5.4"
+    "zod": "^4.6.5"
   },
   "devDependencies": {
     "@abinnovision/eslint-config-base": "^3.4.2",
     "@abinnovision/prettier-config": "^2.2.0",
     "@arethetypeswrong/core": "^0.18.5",
-    "@payloadcms/db-sqlite": "3.88.0",
-    "@payloadcms/richtext-lexical": "3.88.0",
-    "@payloadcms/ui": "3.88.0",
+    "@payloadcms/db-sqlite": "3.89.0",
+    "@payloadcms/richtext-lexical": "3.89.0",
+    "@payloadcms/ui": "3.89.0",
     "@swc/core": "^1.16.2",
     "@types/node": "^26.5.1",
-    "@types/react": "^19.2.18",
+    "@types/react": "^19.3.0",
     "@vitest/coverage-v8": "^5.0.0",
     "eslint": "^10.10.0",
-    "payload": "3.88.0",
+    "payload": "3.89.0",
     "prettier": "^3.9.5",
     "publint": "^0.3.24",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
     "tsdown": "^0.23.0",
     "typescript": "^6.0.3",
     "unplugin-swc": "^1.6.0",