@openspecui/server 3.4.1 → 3.5.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { CliExecutor, CodeEditorThemeSchema, ConfigManager, DASHBOARD_METRIC_KEYS, DashboardConfigSchema, GitConfigSchema, HOSTED_SHELL_PROTOCOL_VERSION, MarkdownParser, OPENSPECUI_HOOKS_VERSION, OpenSpecAdapter, OpenSpecWatcher, OpsxConfigSchema, OpsxKernel, PtyClientMessageSchema, ReactiveContext, TerminalConfigSchema, TerminalRendererEngineSchema, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, getDetectedProjectTools, getToolInitStates, getWatcherRuntimeStatus, initWatcherPool, isWatcherPoolInitialized, resolveTerminalShellDefaults, sniffGlobalCli, subscribeWatcherRuntimeStatus } from "@openspecui/core";
+import { CliExecutor, CodeEditorThemeSchema, ConfigManager, CustomSoundHashSchema, DASHBOARD_METRIC_KEYS, DashboardConfigSchema, GitConfigSchema, HOSTED_SHELL_PROTOCOL_VERSION, MarkdownParser, NotificationPublishInputSchema, NotificationSettingsSchema, OPENSPECUI_HOOKS_VERSION, OpenSpecAdapter, OpenSpecWatcher, OpsxConfigSchema, OpsxKernel, PtyClientMessageSchema, ReactiveContext, TerminalConfigSchema, TerminalControlParser, TerminalRendererEngineSchema, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, getDetectedProjectTools, getToolInitStates, getWatcherRuntimeStatus, initWatcherPool, isWatcherPoolInitialized, resolveTerminalShellDefaults, sniffGlobalCli, subscribeWatcherRuntimeStatus, terminalNotificationEventToPublishInput } from "@openspecui/core";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { access, mkdir, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -10,9 +10,13 @@ import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { readFileSync } from "node:fs";
 import { WebSocketServer } from "ws";
+import { CustomSoundHashSchema as CustomSoundHashSchema$1, CustomSoundIdSchema, CustomSoundMetadataFileSchema, customHashFromSoundId, soundIdFromCustomHash } from "@openspecui/core/sounds";
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
 import { EventEmitter } from "node:events";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { NotificationGroupKeySchema, NotificationPublishInputSchema as NotificationPublishInputSchema$1, getNotificationGroupKey } from "@openspecui/core/notifications";
 import * as pty from "@lydell/node-pty";
 import { EventEmitter as EventEmitter$1 } from "events";
 import { SearchQuerySchema } from "@openspecui/search";
@@ -333,6 +337,135 @@ async function findAvailablePort(startPort, maxAttempts = 10) {
 	throw new Error(`No available port found in range ${startPort}-${startPort + maxAttempts - 1}`);
 }
 
+//#endregion
+//#region src/custom-sound-service.ts
+const METADATA_FILE = "metadatas.json";
+function getDefaultSoundsDir() {
+	return join(homedir(), ".openspecui", "sounds");
+}
+function isNotFound(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function getFallbackName(filename, hash) {
+	const trimmed = filename?.trim();
+	return trimmed ? trimmed.replace(/\.[^.]*$/, "") : hash.slice(0, 12);
+}
+var CustomSoundService = class {
+	soundsDir;
+	metadataPath;
+	constructor(soundsDir = getDefaultSoundsDir()) {
+		this.soundsDir = soundsDir;
+		this.metadataPath = join(soundsDir, METADATA_FILE);
+	}
+	async listAvailable() {
+		const metadatas = await this.readMetadatas();
+		const available = [];
+		for (const metadata of Object.values(metadatas)) if (await this.hasSoundFile(metadata.id)) available.push(metadata);
+		return available.sort((left, right) => right.updatedAt - left.updatedAt);
+	}
+	async upload(input) {
+		if (!input.mime.startsWith("audio/")) throw new Error("Only audio files are supported.");
+		const hash = hashSoundBytes(input.bytes);
+		const now = Date.now();
+		const metadatas = await this.readMetadatas();
+		const previous = metadatas[hash];
+		const metadata = {
+			id: hash,
+			name: previous?.name ?? getFallbackName(input.name, hash),
+			mime: input.mime,
+			size: input.bytes.byteLength,
+			createdAt: previous?.createdAt ?? now,
+			updatedAt: now
+		};
+		await mkdir(this.soundsDir, { recursive: true });
+		await writeFile(this.getSoundPath(hash), input.bytes);
+		await this.writeMetadatas({
+			...metadatas,
+			[hash]: metadata
+		});
+		return metadata;
+	}
+	async rename(id, name) {
+		const hash = this.requireCustomHash(id);
+		const nextName = name.trim();
+		if (!nextName) throw new Error("Sound name is required.");
+		const metadatas = await this.readMetadatas();
+		const current = metadatas[hash];
+		if (!current || !await this.hasSoundFile(hash)) throw new Error("Sound not found.");
+		const next = {
+			...current,
+			name: nextName,
+			updatedAt: Date.now()
+		};
+		await this.writeMetadatas({
+			...metadatas,
+			[hash]: next
+		});
+		return next;
+	}
+	async remove(id) {
+		const hash = this.requireCustomHash(id);
+		const next = { ...await this.readMetadatas() };
+		delete next[hash];
+		await rm(this.getSoundPath(hash), { force: true });
+		await this.writeMetadatas(next);
+	}
+	async getFile(id) {
+		const hash = customHashFromSoundId(id);
+		if (!hash) return null;
+		const metadata = (await this.readMetadatas())[hash];
+		if (!metadata || !await this.hasSoundFile(hash)) return null;
+		return {
+			metadata,
+			data: await readSoundData(this.getSoundPath(hash))
+		};
+	}
+	buildSoundId(hash) {
+		return soundIdFromCustomHash(hash);
+	}
+	requireCustomHash(id) {
+		const hash = customHashFromSoundId(id);
+		if (!hash) throw new Error("Custom sound id is required.");
+		return hash;
+	}
+	getSoundPath(hash) {
+		return join(this.soundsDir, hash);
+	}
+	async hasSoundFile(hash) {
+		try {
+			return (await stat(this.getSoundPath(hash))).isFile();
+		} catch (error) {
+			if (isNotFound(error)) return false;
+			throw error;
+		}
+	}
+	async readMetadatas() {
+		try {
+			const content = await readFile(this.metadataPath, "utf-8");
+			const parsed = JSON.parse(content);
+			const result = CustomSoundMetadataFileSchema.safeParse(parsed);
+			return result.success ? result.data : {};
+		} catch (error) {
+			if (isNotFound(error)) return {};
+			if (error instanceof SyntaxError) return {};
+			throw error;
+		}
+	}
+	async writeMetadatas(metadatas) {
+		await mkdir(this.soundsDir, { recursive: true });
+		await writeFile(this.metadataPath, JSON.stringify(metadatas, null, 2), "utf-8");
+	}
+};
+function hashSoundBytes(bytes) {
+	return CustomSoundHashSchema$1.parse(createHash("sha256").update(bytes).digest("hex"));
+}
+async function readSoundData(path) {
+	const bytes = await readFile(path);
+	const data = new ArrayBuffer(bytes.byteLength);
+	new Uint8Array(data).set(bytes);
+	return data;
+}
+
 //#endregion
 //#region src/dashboard-overview-service.ts
 const REBUILD_DEBOUNCE_MS$1 = 250;
@@ -1206,6 +1339,73 @@ async function loadDashboardOverview(ctx, reason = "dashboard-refresh") {
 	};
 }
 
+//#endregion
+//#region src/notification-service.ts
+var NotificationService = class {
+	notifications = [];
+	listeners = /* @__PURE__ */ new Set();
+	idCounter = 0;
+	list() {
+		return [...this.notifications];
+	}
+	publish(input) {
+		const parsed = NotificationPublishInputSchema$1.parse(input);
+		const groupKey = getNotificationGroupKey(parsed);
+		const createdAt = parsed.createdAt ?? Date.now();
+		const record = {
+			...parsed,
+			id: `notification-${Date.now().toString(36)}-${(++this.idCounter).toString(36)}`,
+			createdAt,
+			groupKey
+		};
+		this.notifications = [record, ...this.notifications];
+		this.emit();
+		return record;
+	}
+	markRead(id) {
+		const next = this.notifications.filter((notification) => notification.id !== id);
+		if (next.length === this.notifications.length) return;
+		this.notifications = next;
+		this.emit();
+	}
+	markManyRead(ids) {
+		if (ids.length === 0) return;
+		const idSet = new Set(ids);
+		const next = this.notifications.filter((notification) => !idSet.has(notification.id));
+		if (next.length === this.notifications.length) return;
+		this.notifications = next;
+		this.emit();
+	}
+	clearGroup(groupKey) {
+		const next = this.notifications.filter((notification) => notification.groupKey !== groupKey);
+		if (next.length === this.notifications.length) return;
+		this.notifications = next;
+		this.emit();
+	}
+	clearTerminalSession(sessionId) {
+		const next = this.notifications.filter((notification) => notification.source.type !== "terminal" || notification.source.sessionId !== sessionId);
+		if (next.length === this.notifications.length) return;
+		this.notifications = next;
+		this.emit();
+	}
+	clearAll() {
+		if (this.notifications.length === 0) return;
+		this.notifications = [];
+		this.emit();
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		listener(this.list());
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	emit() {
+		const snapshot = this.list();
+		for (const listener of this.listeners) listener(snapshot);
+	}
+};
+
 //#endregion
 //#region src/project-recovery-service.ts
 function normalizeWorktreeBranchName(defaultBranch) {
@@ -1454,6 +1654,8 @@ var PtySession = class extends EventEmitter$1 {
 	process;
 	titleInterval = null;
 	lastTitle = "";
+	lastOscIconTitle = "";
+	lastOscWindowTitle = "";
 	buffer = [];
 	bufferByteLength = 0;
 	maxBufferLines;
@@ -1513,6 +1715,18 @@ var PtySession = class extends EventEmitter$1 {
 	get title() {
 		return this.lastTitle;
 	}
+	get targetTitle() {
+		return this.lastOscIconTitle || this.lastOscWindowTitle || this.lastTitle || this.command;
+	}
+	get oscTitle() {
+		return this.lastOscIconTitle || this.lastOscWindowTitle;
+	}
+	setTargetTitle(title, target) {
+		const trimmed = title.trim();
+		if (!trimmed) return;
+		if (target === "icon" || target === "both") this.lastOscIconTitle = trimmed;
+		if (target === "window" || target === "both") this.lastOscWindowTitle = trimmed;
+	}
 	appendBuffer(data) {
 		let chunk = data;
 		if (chunk.length > this.maxBufferBytes) chunk = chunk.slice(-this.maxBufferBytes);
@@ -1621,9 +1835,35 @@ var PtyManager = class {
 
 //#endregion
 //#region src/pty-websocket.ts
-function createPtyWebSocketHandler(ptyManager) {
+function resolveTerminalTargetTitle(session, title) {
+	return title?.trim() || session.targetTitle || session.title || session.command;
+}
+function updateTerminalTargetTitle(session, event) {
+	session.setTargetTitle(event.title, event.target);
+}
+function normalizeTerminalNotificationBody(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function getTerminalNotificationFanoutKey(event) {
+	return normalizeTerminalNotificationBody(event.body) || normalizeTerminalNotificationBody(event.title ?? "");
+}
+function coalesceTerminalNotificationFanout(events) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const key = getTerminalNotificationFanoutKey(event);
+		const group = groups.get(key);
+		if (group) group.push(event);
+		else groups.set(key, [event]);
+	}
+	return [...groups.values()].flatMap((group) => {
+		if (new Set(group.map((event) => event.protocol)).size <= 1) return group;
+		return group.find((event) => event.title) ?? group[0] ?? [];
+	});
+}
+function createPtyWebSocketHandler(ptyManager, notificationService) {
 	return (ws) => {
 		const cleanups = /* @__PURE__ */ new Map();
+		const parsers = /* @__PURE__ */ new Map();
 		const send = (msg) => {
 			if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
 		};
@@ -1640,10 +1880,68 @@ function createPtyWebSocketHandler(ptyManager) {
 			cleanups.get(sessionId)?.();
 			if (opts?.cols && opts?.rows && !session.isExited) session.resize(opts.cols, opts.rows);
 			const onData = (data) => {
-				send({
+				const parser = parsers.get(sessionId) ?? new TerminalControlParser();
+				parsers.set(sessionId, parser);
+				const parsed = parser.push(data);
+				const notifications = coalesceTerminalNotificationFanout(parsed.events.filter((event) => event.type === "notification"));
+				const notificationsToPublish = new Set(notifications);
+				for (const event of parsed.events) {
+					if (event.type === "bell") {
+						send({
+							type: "bell",
+							sessionId,
+							createdAt: Date.now()
+						});
+						continue;
+					}
+					if (event.type === "notification") {
+						if (!notificationsToPublish.has(event)) continue;
+						notificationService?.publish(terminalNotificationEventToPublishInput({
+							event,
+							sessionId,
+							terminalTitle: resolveTerminalTargetTitle(session)
+						}));
+						continue;
+					}
+					if (event.type === "title") {
+						const previousTargetTitle = session.targetTitle;
+						updateTerminalTargetTitle(session, event);
+						const nextTargetTitle = resolveTerminalTargetTitle(session);
+						if (nextTargetTitle !== previousTargetTitle) send({
+							type: "title",
+							sessionId,
+							title: nextTargetTitle
+						});
+						continue;
+					}
+					if (event.type === "cwd") {
+						send({
+							type: "cwd",
+							sessionId,
+							cwd: event.cwd
+						});
+						continue;
+					}
+					if (event.type === "progress") {
+						send({
+							type: "progress",
+							sessionId,
+							state: event.state,
+							value: event.value
+						});
+						continue;
+					}
+					if (event.type === "prompt-state") send({
+						type: "prompt-state",
+						sessionId,
+						state: event.state,
+						exitCode: event.exitCode
+					});
+				}
+				if (parsed.output) send({
 					type: "output",
 					sessionId,
-					data
+					data: parsed.output
 				});
 			};
 			const onExit = (exitCode) => {
@@ -1655,10 +1953,15 @@ function createPtyWebSocketHandler(ptyManager) {
 			};
 			const onTitle = (title) => {
 				send({
-					type: "title",
+					type: "process-title",
 					sessionId,
 					title
 				});
+				send({
+					type: "title",
+					sessionId,
+					title: resolveTerminalTargetTitle(session)
+				});
 			};
 			session.on("data", onData);
 			session.on("exit", onExit);
@@ -1667,6 +1970,7 @@ function createPtyWebSocketHandler(ptyManager) {
 				session.removeListener("data", onData);
 				session.removeListener("exit", onExit);
 				session.removeListener("title", onTitle);
+				parsers.delete(sessionId);
 				cleanups.delete(sessionId);
 			});
 		};
@@ -1730,10 +2034,15 @@ function createPtyWebSocketHandler(ptyManager) {
 						data: buffer
 					});
 					if (session.title) send({
-						type: "title",
+						type: "process-title",
 						sessionId: session.id,
 						title: session.title
 					});
+					if (session.title || session.oscTitle) send({
+						type: "title",
+						sessionId: session.id,
+						title: resolveTerminalTargetTitle(session)
+					});
 					if (session.isExited) send({
 						type: "exit",
 						sessionId: session.id,
@@ -2596,6 +2905,59 @@ function createReactiveSubscriptionWithInput(task) {
 const t = initTRPC.context().create();
 const router = t.router;
 const publicProcedure = t.procedure;
+const notificationsRouter = router({
+	list: publicProcedure.query(({ ctx }) => {
+		return ctx.notificationService.list();
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return observable((emit) => {
+			const unsubscribe = ctx.notificationService.subscribe((notifications) => {
+				emit.next(notifications);
+			});
+			return () => {
+				unsubscribe();
+			};
+		});
+	}),
+	publish: publicProcedure.input(NotificationPublishInputSchema$1).mutation(({ ctx, input }) => {
+		return ctx.notificationService.publish(input);
+	}),
+	markRead: publicProcedure.input(z.object({ id: z.string().min(1) })).mutation(({ ctx, input }) => {
+		ctx.notificationService.markRead(input.id);
+		return { success: true };
+	}),
+	markManyRead: publicProcedure.input(z.object({ ids: z.array(z.string().min(1)).default([]) })).mutation(({ ctx, input }) => {
+		ctx.notificationService.markManyRead(input.ids);
+		return { success: true };
+	}),
+	clearGroup: publicProcedure.input(z.object({ groupKey: NotificationGroupKeySchema })).mutation(({ ctx, input }) => {
+		ctx.notificationService.clearGroup(input.groupKey);
+		return { success: true };
+	}),
+	clearTerminalSession: publicProcedure.input(z.object({ sessionId: z.string().min(1) })).mutation(({ ctx, input }) => {
+		ctx.notificationService.clearTerminalSession(input.sessionId);
+		return { success: true };
+	}),
+	clearAll: publicProcedure.mutation(({ ctx }) => {
+		ctx.notificationService.clearAll();
+		return { success: true };
+	})
+});
+const soundsRouter = router({
+	listCustom: publicProcedure.query(({ ctx }) => {
+		return ctx.customSoundService.listAvailable();
+	}),
+	renameCustom: publicProcedure.input(z.object({
+		id: CustomSoundIdSchema,
+		name: z.string().min(1).max(160)
+	})).mutation(({ ctx, input }) => {
+		return ctx.customSoundService.rename(input.id, input.name);
+	}),
+	deleteCustom: publicProcedure.input(z.object({ id: CustomSoundIdSchema })).mutation(async ({ ctx, input }) => {
+		await ctx.customSoundService.remove(input.id);
+		return { success: true };
+	})
+});
 const OPSX_CORE_PROFILE_WORKFLOWS = [
 	"propose",
 	"explore",
@@ -3032,20 +3394,22 @@ const configRouter = router({
 		opsx: OpsxConfigSchema.partial().optional(),
 		terminal: TerminalConfigSchema.omit({ rendererEngine: true }).partial().extend({ rendererEngine: TerminalRendererEngineSchema.optional() }).optional(),
 		dashboard: DashboardConfigSchema.partial().optional(),
-		git: GitConfigSchema.partial().optional()
+		git: GitConfigSchema.partial().optional(),
+		notifications: NotificationSettingsSchema.partial().optional()
 	})).mutation(async ({ ctx, input }) => {
 		const hasCliCommand = input.cli !== void 0 && Object.prototype.hasOwnProperty.call(input.cli, "command");
 		const hasCliArgs = input.cli !== void 0 && Object.prototype.hasOwnProperty.call(input.cli, "args");
 		if (hasCliCommand && !hasCliArgs) {
 			await ctx.configManager.setCliCommand(input.cli?.command ?? "");
-			if (input.theme !== void 0 || input.codeEditor !== void 0 || input.appBaseUrl !== void 0 || input.opsx !== void 0 || input.terminal !== void 0 || input.dashboard !== void 0 || input.git !== void 0) await ctx.configManager.writeConfig({
+			if (input.theme !== void 0 || input.codeEditor !== void 0 || input.appBaseUrl !== void 0 || input.opsx !== void 0 || input.terminal !== void 0 || input.dashboard !== void 0 || input.git !== void 0 || input.notifications !== void 0) await ctx.configManager.writeConfig({
 				theme: input.theme,
 				codeEditor: input.codeEditor,
 				appBaseUrl: input.appBaseUrl,
 				opsx: input.opsx,
 				terminal: input.terminal,
 				dashboard: input.dashboard,
-				git: input.git
+				git: input.git,
+				notifications: input.notifications
 			});
 			return { success: true };
 		}
@@ -3687,6 +4051,8 @@ const appRouter = router({
 	init: initRouter,
 	realtime: realtimeRouter,
 	config: configRouter,
+	notifications: notificationsRouter,
+	sounds: soundsRouter,
 	cli: cliRouter,
 	opsx: opsxRouter,
 	kv: kvRouter,
@@ -4083,6 +4449,8 @@ function createServer(config) {
 		hookRuntime,
 		executeCli: (args) => cliExecutor.execute(args)
 	});
+	const notificationService = new NotificationService();
+	const customSoundService = new CustomSoundService();
 	const watcher = config.enableWatcher !== false ? new OpenSpecWatcher(config.projectDir) : void 0;
 	const searchService = new SearchService(adapter, watcher, void 0, documentService);
 	const dashboardOverviewService = new DashboardOverviewService((reason) => loadDashboardOverview({
@@ -4111,6 +4479,38 @@ function createServer(config) {
 			embeddedUiUrl: buildEmbeddedUiUrlForPort(config.port ?? 3100)
 		});
 	});
+	app.post("/api/notifications", async (c) => {
+		const body = await c.req.json().catch(() => null);
+		const parsed = NotificationPublishInputSchema.safeParse(body);
+		if (!parsed.success) return c.json({
+			error: "Invalid notification payload",
+			issues: parsed.error.issues
+		}, 400);
+		return c.json(notificationService.publish(parsed.data));
+	});
+	app.post("/api/sounds/custom", async (c) => {
+		const formData = await c.req.formData().catch(() => null);
+		const file = formData?.get("file");
+		const nameValue = formData?.get("name");
+		if (!(file instanceof File)) return c.json({ error: "Audio file is required." }, 400);
+		const metadata = await customSoundService.upload({
+			bytes: new Uint8Array(await file.arrayBuffer()),
+			name: typeof nameValue === "string" ? nameValue : file.name,
+			mime: file.type || "audio/mpeg"
+		});
+		return c.json(metadata);
+	});
+	app.get("/api/sounds/custom/:id", async (c) => {
+		const id = c.req.param("id");
+		const parsedId = CustomSoundHashSchema.safeParse(id);
+		if (!parsedId.success) return c.json({ error: "Sound not found." }, 404);
+		const file = await customSoundService.getFile(`custom:${parsedId.data}`);
+		if (!file) return c.json({ error: "Sound not found." }, 404);
+		return new Response(new Blob([file.data], { type: file.metadata.mime }), { headers: {
+			"Content-Type": file.metadata.mime,
+			"Cache-Control": "private, max-age=31536000, immutable"
+		} });
+	});
 	app.use("/trpc/*", async (c) => {
 		return await fetchRequestHandler({
 			endpoint: "/trpc",
@@ -4126,6 +4526,8 @@ function createServer(config) {
 				searchService,
 				dashboardOverviewService,
 				projectRecoveryService,
+				notificationService,
+				customSoundService,
 				gitWorktreeHandoff: config.gitWorktreeHandoff,
 				watcher,
 				projectDir: config.projectDir
@@ -4142,6 +4544,8 @@ function createServer(config) {
 		searchService,
 		dashboardOverviewService,
 		projectRecoveryService,
+		notificationService,
+		customSoundService,
 		gitWorktreeHandoff: config.gitWorktreeHandoff,
 		watcher,
 		projectDir: config.projectDir
@@ -4157,6 +4561,8 @@ function createServer(config) {
 		searchService,
 		dashboardOverviewService,
 		projectRecoveryService,
+		notificationService,
+		customSoundService,
 		hookRuntime,
 		watcher,
 		createContext,
@@ -4181,7 +4587,7 @@ async function createWebSocketServer(server, httpServer, config) {
 	});
 	const ptyManager = new PtyManager(config.projectDir);
 	const ptyWss = new WebSocketServer({ noServer: true });
-	const ptyHandler = createPtyWebSocketHandler(ptyManager);
+	const ptyHandler = createPtyWebSocketHandler(ptyManager, server.notificationService);
 	ptyWss.on("connection", ptyHandler);
 	httpServer.on("upgrade", (...args) => {
 		const [request, socket, head] = args;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openspecui/server",
-  "version": "3.4.1",
+  "version": "3.5.0",
   "type": "module",
   "main": "dist/index.mjs",
   "exports": {