voice-page-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,596 @@
+import { defineComponent, ref, onMounted, onBeforeUnmount, h, inject, getCurrentInstance } from 'vue-demi';
+
+// src/controller.ts
+var DEFAULT_WAKE_WORD = "\u5E03\u4E01\u5E03\u4E01";
+var DEFAULT_OPTIONS = {
+  wakeWord: [DEFAULT_WAKE_WORD],
+  enableHomophoneMatch: true,
+  wakeCooldownMs: 1400,
+  commandInitialTimeoutMs: 12e3,
+  commandSilenceTimeoutMs: 2600,
+  commandMaxWindowMs: 22e3,
+  recognitionLang: "zh-CN",
+  showAgentWhenWake: true,
+  autoStart: false
+};
+var HOMOPHONE_VARIANTS = {
+  \u5E03: ["\u8865", "\u4E0D", "\u6B65", "\u90E8"],
+  \u4E01: ["\u53EE", "\u9489", "\u76EF", "\u9876"],
+  \u5C0F: ["\u6653", "\u7B11", "\u6821", "\u7B71"],
+  \u73ED: ["\u822C", "\u6591", "\u534A"]
+};
+function normalizeText(text) {
+  return (text || "").toLowerCase().replace(/[\s,，.。!！?？;；:：、"'`~\-_/\\]/g, "");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function levenshteinDistance(source, target) {
+  const a = Array.from(source);
+  const b = Array.from(target);
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  const dp = Array.from(
+    { length: a.length + 1 },
+    () => Array.from({ length: b.length + 1 }, () => 0)
+  );
+  for (let i = 0; i <= a.length; i += 1) dp[i][0] = i;
+  for (let j = 0; j <= b.length; j += 1) dp[0][j] = j;
+  for (let i = 1; i <= a.length; i += 1) {
+    for (let j = 1; j <= b.length; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return dp[a.length][b.length];
+}
+function makeHomophoneRegex(words) {
+  const fuzzyWords = words.map((word) => {
+    const chars = Array.from(word);
+    return chars.map((char) => {
+      const variants = HOMOPHONE_VARIANTS[char] || [];
+      const options = [char, ...variants].map((item) => escapeRegExp(item));
+      return `(?:${options.join("|")})`;
+    }).join("");
+  });
+  return new RegExp(fuzzyWords.join("|"));
+}
+function buildWakeRegex(words) {
+  const items = words.map((word) => normalizeText(word)).filter(Boolean).sort((a, b) => b.length - a.length).map((word) => escapeRegExp(word));
+  const body = items.length ? items.join("|") : escapeRegExp(normalizeText(DEFAULT_WAKE_WORD));
+  return {
+    single: new RegExp(`(${body})`),
+    global: new RegExp(`(${body})`, "g")
+  };
+}
+function resolveOptions(options) {
+  if (!(options == null ? void 0 : options.pageAgent) || typeof options.pageAgent !== "object") {
+    throw new Error("voice-page-agent: options.pageAgent is required");
+  }
+  const wakeWordInput = options.wakeWord;
+  const wakeWord = Array.isArray(wakeWordInput) ? wakeWordInput.filter(Boolean) : [wakeWordInput || DEFAULT_WAKE_WORD];
+  return {
+    ...DEFAULT_OPTIONS,
+    ...options,
+    pageAgent: options.pageAgent,
+    wakeWord
+  };
+}
+var VoicePageAgentController = class {
+  constructor(options) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.state = {
+      status: "off",
+      message: "\u8BED\u97F3\u52A9\u624B\u672A\u5F00\u542F",
+      supported: false,
+      enabled: false,
+      micPermissionGranted: false
+    };
+    this.recognition = null;
+    this.initAgentPromise = null;
+    this.voiceEnabled = false;
+    this.disposed = false;
+    this.awaitingCommand = false;
+    this.commandFinalText = "";
+    this.commandInterimText = "";
+    this.commandTimer = null;
+    this.commandDeadlineTimer = null;
+    this.restartBusy = false;
+    this.lastWakeAt = 0;
+    this.options = resolveOptions(options);
+    this.wakeRegex = buildWakeRegex(this.options.wakeWord);
+    this.wakeHomophoneRegex = this.options.enableHomophoneMatch ? makeHomophoneRegex(this.options.wakeWord) : null;
+    this.patchState({
+      supported: this.hasSpeechSupport(),
+      status: this.hasSpeechSupport() ? "off" : "unsupported",
+      message: this.hasSpeechSupport() ? "\u8BED\u97F3\u52A9\u624B\u672A\u5F00\u542F" : "\u5F53\u524D\u6D4F\u89C8\u5668\u4E0D\u652F\u6301\u8BED\u97F3\u8BC6\u522B\uFF0C\u5EFA\u8BAE\u4F7F\u7528 Chrome/Edge"
+    });
+    if (typeof window !== "undefined") {
+      const saved = window.localStorage.getItem("voice-page-agent-enabled");
+      if (saved === "1" || this.options.autoStart) {
+        void this.startWake();
+      }
+      void this.syncPermissionState();
+    }
+  }
+  get snapshot() {
+    return { ...this.state };
+  }
+  onStateChange(listener) {
+    this.listeners.add(listener);
+    listener(this.snapshot);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async openAgent() {
+    return this.ensureAgent();
+  }
+  async startWake() {
+    if (this.disposed) return;
+    if (!this.hasSpeechSupport()) {
+      this.patchState({
+        status: "unsupported",
+        supported: false,
+        message: "\u5F53\u524D\u6D4F\u89C8\u5668\u4E0D\u652F\u6301\u8BED\u97F3\u8BC6\u522B\uFF0C\u5EFA\u8BAE\u4F7F\u7528 Chrome/Edge"
+      });
+      return;
+    }
+    if (this.voiceEnabled) {
+      this.patchState({
+        status: "waking",
+        enabled: true,
+        message: `\u8BED\u97F3\u5DF2\u5F00\u542F\uFF0C\u8BF7\u8BF4\u201C${this.options.wakeWord[0]}\u201D\u5524\u9192\u52A9\u624B`
+      });
+      return;
+    }
+    const granted = await this.requestMicrophonePermission();
+    if (!granted) {
+      this.patchState({
+        status: "error",
+        enabled: false,
+        micPermissionGranted: false,
+        message: "\u9EA6\u514B\u98CE\u6388\u6743\u5931\u8D25\uFF0C\u8BF7\u5141\u8BB8\u6D4F\u89C8\u5668\u4F7F\u7528\u9EA6\u514B\u98CE"
+      });
+      return;
+    }
+    const recognition = this.recognition || this.buildRecognition();
+    if (!recognition) {
+      this.patchState({
+        status: "error",
+        enabled: false,
+        message: "\u8BED\u97F3\u8BC6\u522B\u521D\u59CB\u5316\u5931\u8D25"
+      });
+      return;
+    }
+    this.recognition = recognition;
+    this.voiceEnabled = true;
+    this.patchState({
+      status: "waking",
+      enabled: true,
+      micPermissionGranted: true,
+      message: `\u8BED\u97F3\u5DF2\u5F00\u542F\uFF0C\u8BF7\u8BF4\u201C${this.options.wakeWord[0]}\u201D\u5524\u9192\u52A9\u624B`
+    });
+    window.localStorage.setItem("voice-page-agent-enabled", "1");
+    try {
+      recognition.start();
+    } catch {
+    }
+  }
+  stopWake() {
+    this.voiceEnabled = false;
+    this.awaitingCommand = false;
+    this.commandFinalText = "";
+    this.commandInterimText = "";
+    this.clearCommandTimer();
+    this.clearCommandDeadlineTimer();
+    this.patchState({
+      status: "off",
+      enabled: false,
+      message: "\u8BED\u97F3\u52A9\u624B\u5DF2\u5173\u95ED"
+    });
+    if (typeof window !== "undefined") {
+      window.localStorage.setItem("voice-page-agent-enabled", "0");
+    }
+    if (this.recognition) {
+      this.recognition.stop();
+    }
+  }
+  async runCommand(commandText) {
+    await this.executeVoiceCommand(commandText);
+  }
+  dispose() {
+    this.disposed = true;
+    this.stopWake();
+    if (this.recognition) {
+      this.recognition.abort();
+      this.recognition = null;
+    }
+    this.listeners.clear();
+  }
+  hasSpeechSupport() {
+    if (typeof window === "undefined") return false;
+    const runtimeWindow = window;
+    return Boolean(runtimeWindow.SpeechRecognition || runtimeWindow.webkitSpeechRecognition);
+  }
+  patchState(next) {
+    this.state = { ...this.state, ...next };
+    const snapshot = this.snapshot;
+    this.listeners.forEach((listener) => listener(snapshot));
+  }
+  clearCommandTimer() {
+    if (this.commandTimer !== null) {
+      window.clearTimeout(this.commandTimer);
+      this.commandTimer = null;
+    }
+  }
+  clearCommandDeadlineTimer() {
+    if (this.commandDeadlineTimer !== null) {
+      window.clearTimeout(this.commandDeadlineTimer);
+      this.commandDeadlineTimer = null;
+    }
+  }
+  composeCommandText() {
+    return `${this.commandFinalText} ${this.commandInterimText}`.trim();
+  }
+  scheduleFlushCommand(ms) {
+    this.clearCommandTimer();
+    this.commandTimer = window.setTimeout(() => {
+      this.flushVoiceCommand();
+    }, ms);
+  }
+  scheduleCommandDeadline() {
+    this.clearCommandDeadlineTimer();
+    this.commandDeadlineTimer = window.setTimeout(() => {
+      this.flushVoiceCommand();
+    }, this.options.commandMaxWindowMs);
+  }
+  flushVoiceCommand() {
+    this.clearCommandTimer();
+    this.clearCommandDeadlineTimer();
+    const command = this.sanitizeVoiceCommand(this.composeCommandText());
+    this.awaitingCommand = false;
+    this.commandFinalText = "";
+    this.commandInterimText = "";
+    void this.executeVoiceCommand(command);
+  }
+  isWakePhraseHit(text) {
+    var _a;
+    const normalized = normalizeText(text);
+    if (!normalized) return false;
+    if (this.options.wakeWord.some((word) => normalized.includes(normalizeText(word)))) {
+      return true;
+    }
+    if (this.options.enableHomophoneMatch && ((_a = this.wakeHomophoneRegex) == null ? void 0 : _a.test(normalized))) {
+      return true;
+    }
+    const candidates = this.options.wakeWord.map((word) => normalizeText(word));
+    for (const candidate of candidates) {
+      if (Math.abs(candidate.length - normalized.length) > 1) continue;
+      if (levenshteinDistance(normalized, candidate) <= 1) {
+        return true;
+      }
+    }
+    return false;
+  }
+  extractCommandAfterWake(text) {
+    const source = (text || "").trim();
+    if (!source) return "";
+    const match = source.match(this.wakeRegex.single);
+    if (!match || typeof match.index !== "number") return "";
+    const rest = source.slice(match.index + match[0].length);
+    return rest.replace(/^[\s,，.。!！?？;；:：、]+/, "").trim();
+  }
+  sanitizeVoiceCommand(text) {
+    return (text || "").replace(this.wakeRegex.global, "").replace(/^[\s,，.。!！?？;；:：、]+/, "").trim();
+  }
+  async requestMicrophonePermission() {
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      stream.getTracks().forEach((track) => track.stop());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async syncPermissionState() {
+    var _a;
+    if (!("permissions" in navigator) || !((_a = navigator.permissions) == null ? void 0 : _a.query)) return;
+    try {
+      const result = await navigator.permissions.query({
+        name: "microphone"
+      });
+      this.patchState({ micPermissionGranted: result.state === "granted" });
+      result.onchange = () => {
+        this.patchState({ micPermissionGranted: result.state === "granted" });
+      };
+    } catch {
+    }
+  }
+  async ensureAgent() {
+    if (typeof window === "undefined") return null;
+    const runtimeWindow = window;
+    if (runtimeWindow.pageAgent) {
+      runtimeWindow.pageAgent.panel.show();
+      runtimeWindow.pageAgent.panel.expand();
+      return runtimeWindow.pageAgent;
+    }
+    if (this.initAgentPromise) return this.initAgentPromise;
+    this.initAgentPromise = (async () => {
+      const mod = await import('page-agent');
+      const Agent = mod.PageAgent;
+      const agent = new Agent(this.options.pageAgent);
+      runtimeWindow.pageAgent = agent;
+      agent.panel.show();
+      agent.panel.expand();
+      return agent;
+    })().catch((err) => {
+      this.patchState({
+        status: "error",
+        message: err instanceof Error ? err.message : "Page Agent \u521D\u59CB\u5316\u5931\u8D25"
+      });
+      return null;
+    }).finally(() => {
+      this.initAgentPromise = null;
+    });
+    return this.initAgentPromise;
+  }
+  async executeVoiceCommand(rawCommand) {
+    const command = this.sanitizeVoiceCommand(rawCommand);
+    if (!command) {
+      this.patchState({
+        status: "waking",
+        message: `\u672A\u8BC6\u522B\u5230\u6307\u4EE4\uFF0C\u8BF7\u518D\u8BF4\u4E00\u6B21\u201C${this.options.wakeWord[0]}\u201D`
+      });
+      return;
+    }
+    this.patchState({
+      status: "processing",
+      message: `\u5DF2\u8BC6\u522B\uFF1A${command}`
+    });
+    const agent = await this.ensureAgent();
+    if (!agent) return;
+    if (agent.status === "running") {
+      this.patchState({
+        status: "waking",
+        message: "\u52A9\u624B\u6B63\u5728\u6267\u884C\u4E2D\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BF4"
+      });
+      return;
+    }
+    try {
+      await agent.execute(command);
+      this.patchState({
+        status: "waking",
+        message: `\u4EFB\u52A1\u5DF2\u63D0\u4EA4\u5B8C\u6210\uFF0C\u7EE7\u7EED\u7B49\u5F85\u201C${this.options.wakeWord[0]}\u201D`
+      });
+    } catch (err) {
+      this.patchState({
+        status: "error",
+        message: err instanceof Error ? err.message : "\u8BED\u97F3\u4EFB\u52A1\u6267\u884C\u5931\u8D25"
+      });
+    }
+  }
+  buildRecognition() {
+    const runtimeWindow = window;
+    const Ctor = runtimeWindow.SpeechRecognition || runtimeWindow.webkitSpeechRecognition;
+    if (!Ctor) return null;
+    const recognition = new Ctor();
+    recognition.lang = this.options.recognitionLang;
+    recognition.continuous = true;
+    recognition.interimResults = true;
+    recognition.maxAlternatives = 3;
+    recognition.onstart = () => {
+      if (!this.voiceEnabled) return;
+      this.patchState({
+        status: "waking",
+        message: `\u8BED\u97F3\u5DF2\u5F00\u542F\uFF0C\u8BF7\u8BF4\u201C${this.options.wakeWord[0]}\u201D\u5524\u9192\u52A9\u624B`
+      });
+    };
+    recognition.onresult = (event) => {
+      var _a;
+      for (let i = event.resultIndex; i < event.results.length; i += 1) {
+        const result = event.results[i];
+        const isFinal = Boolean(result == null ? void 0 : result.isFinal);
+        const transcript = String(((_a = result[0]) == null ? void 0 : _a.transcript) || "").trim();
+        if (!transcript) continue;
+        if (!this.awaitingCommand) {
+          if (!this.isWakePhraseHit(transcript)) continue;
+          const now = Date.now();
+          if (now - this.lastWakeAt < this.options.wakeCooldownMs) continue;
+          this.lastWakeAt = now;
+          this.awaitingCommand = true;
+          this.commandFinalText = "";
+          this.commandInterimText = "";
+          this.patchState({
+            status: "listening_command",
+            message: "\u5DF2\u5524\u9192\uFF0C\u8BF7\u8BF4\u51FA\u4F60\u7684\u6307\u4EE4\uFF08\u53EF\u8FDE\u7EED\u8BF4\u66F4\u957F\u5185\u5BB9\uFF09"
+          });
+          if (this.options.showAgentWhenWake) {
+            void this.ensureAgent();
+          }
+          const inlineCommand = isFinal ? this.extractCommandAfterWake(transcript) : "";
+          if (inlineCommand) {
+            this.commandFinalText = inlineCommand;
+            this.scheduleFlushCommand(this.options.commandSilenceTimeoutMs);
+          } else {
+            this.scheduleFlushCommand(this.options.commandInitialTimeoutMs);
+          }
+          this.scheduleCommandDeadline();
+          continue;
+        }
+        if (isFinal) {
+          this.commandFinalText = `${this.commandFinalText} ${transcript}`.trim();
+          this.commandInterimText = "";
+        } else {
+          this.commandInterimText = transcript;
+        }
+        this.patchState({
+          status: "listening_command",
+          message: `\u6B63\u5728\u8BC6\u522B\uFF1A${this.composeCommandText() || "\u8BF7\u7EE7\u7EED\u8BF4\u8BDD..."}`
+        });
+        this.scheduleFlushCommand(this.options.commandSilenceTimeoutMs);
+      }
+    };
+    recognition.onerror = (event) => {
+      const code = String(event.error || "");
+      if (code === "no-speech" || code === "aborted") return;
+      if (code === "not-allowed" || code === "service-not-allowed") {
+        this.voiceEnabled = false;
+        this.patchState({
+          status: "error",
+          enabled: false,
+          micPermissionGranted: false,
+          message: "\u9EA6\u514B\u98CE\u6743\u9650\u88AB\u62D2\u7EDD\uFF0C\u8BF7\u5728\u6D4F\u89C8\u5668\u8BBE\u7F6E\u4E2D\u5141\u8BB8\u9EA6\u514B\u98CE"
+        });
+        window.localStorage.setItem("voice-page-agent-enabled", "0");
+        return;
+      }
+      this.patchState({
+        status: "error",
+        message: `\u8BED\u97F3\u8BC6\u522B\u5F02\u5E38\uFF1A${code || "\u672A\u77E5\u9519\u8BEF"}`
+      });
+    };
+    recognition.onend = () => {
+      if (!this.voiceEnabled || this.disposed) return;
+      if (this.restartBusy) return;
+      this.restartBusy = true;
+      window.setTimeout(() => {
+        this.restartBusy = false;
+        if (!this.voiceEnabled || this.disposed) return;
+        try {
+          recognition.start();
+        } catch {
+        }
+      }, 320);
+    };
+    return recognition;
+  }
+};
+function createVoicePageAgent(options) {
+  return new VoicePageAgentController(options);
+}
+var VOICE_PAGE_AGENT_KEY = "VOICE_PAGE_AGENT_INSTANCE";
+var defaultController = null;
+function attachToApp(target, controller) {
+  var _a, _b, _c, _d, _e;
+  const anyTarget = target;
+  if ("config" in anyTarget && ((_a = anyTarget.config) == null ? void 0 : _a.globalProperties)) {
+    anyTarget.config.globalProperties.$voicePageAgent = controller;
+    (_b = anyTarget.provide) == null ? void 0 : _b.call(anyTarget, VOICE_PAGE_AGENT_KEY, controller);
+    (_c = anyTarget.component) == null ? void 0 : _c.call(anyTarget, "VoicePageAgentButton", VoicePageAgentButton);
+    return;
+  }
+  anyTarget.prototype.$voicePageAgent = controller;
+  (_d = anyTarget.component) == null ? void 0 : _d.call(anyTarget, "VoicePageAgentButton", VoicePageAgentButton);
+  (_e = anyTarget.mixin) == null ? void 0 : _e.call(anyTarget, {
+    provide() {
+      return {
+        [VOICE_PAGE_AGENT_KEY]: controller
+      };
+    }
+  });
+}
+function useVoicePageAgent() {
+  const injected = inject(VOICE_PAGE_AGENT_KEY, null);
+  if (injected) return injected;
+  const instance = getCurrentInstance();
+  const proxy = instance == null ? void 0 : instance.proxy;
+  if (proxy == null ? void 0 : proxy.$voicePageAgent) return proxy.$voicePageAgent;
+  if (defaultController) return defaultController;
+  throw new Error("voice-page-agent: controller not found, please install plugin first.");
+}
+var VoicePageAgentButton = defineComponent({
+  name: "VoicePageAgentButton",
+  props: {
+    showStatus: {
+      type: Boolean,
+      default: true
+    },
+    startText: {
+      type: String,
+      default: "\u5F00\u542F\u8BED\u97F3\u5524\u9192"
+    },
+    wakeOnText: {
+      type: String,
+      default: "\u8BED\u97F3\u5524\u9192\u4E2D"
+    },
+    openText: {
+      type: String,
+      default: "\u7F51\u9875\u52A9\u624B"
+    }
+  },
+  setup(props) {
+    const controller = useVoicePageAgent();
+    const state = ref(controller.snapshot);
+    let off = null;
+    onMounted(() => {
+      off = controller.onStateChange((next) => {
+        state.value = next;
+      });
+    });
+    onBeforeUnmount(() => {
+      off == null ? void 0 : off();
+      off = null;
+    });
+    const handleWakeClick = () => {
+      if (state.value.enabled) {
+        controller.stopWake();
+      } else {
+        void controller.startWake();
+      }
+    };
+    const handleOpenClick = () => {
+      void controller.openAgent();
+    };
+    return () => h("div", { class: "voice-page-agent-root" }, [
+      h("div", { class: "voice-page-agent-actions" }, [
+        state.value.supported && !state.value.micPermissionGranted ? h(
+          "button",
+          {
+            type: "button",
+            class: "voice-page-agent-btn",
+            onClick: handleWakeClick
+          },
+          state.value.enabled ? props.wakeOnText : props.startText
+        ) : null,
+        h(
+          "button",
+          {
+            type: "button",
+            class: "voice-page-agent-btn",
+            onClick: handleOpenClick
+          },
+          props.openText
+        )
+      ]),
+      props.showStatus ? h("p", { class: "voice-page-agent-status" }, state.value.message) : null
+    ]);
+  }
+});
+function createVoicePageAgentPlugin(options) {
+  const controller = createVoicePageAgent(options);
+  defaultController = controller;
+  return {
+    install(app) {
+      attachToApp(app, controller);
+    },
+    controller
+  };
+}
+var VoicePageAgentVuePlugin = {
+  install(app, options) {
+    if (!options) {
+      throw new Error("voice-page-agent: install options is required.");
+    }
+    const plugin = createVoicePageAgentPlugin(options);
+    VoicePageAgentVuePlugin.controller = plugin.controller;
+    attachToApp(app, plugin.controller);
+  }
+};
+var plugin_default = VoicePageAgentVuePlugin;
+
+export { VoicePageAgentButton, VoicePageAgentController, plugin_default as VoicePageAgentPlugin, createVoicePageAgent, createVoicePageAgentPlugin, useVoicePageAgent };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "voice-page-agent",
+  "version": "0.1.0",
+  "description": "Voice wake plugin for page-agent with Vue2/Vue3 compatibility.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "voice",
+    "wake-word",
+    "page-agent",
+    "vue2",
+    "vue3"
+  ],
+  "peerDependencies": {
+    "page-agent": ">=0.2.0",
+    "vue": "^2.6.14 || ^3.2.0"
+  },
+  "peerDependenciesMeta": {
+    "page-agent": {
+      "optional": false
+    }
+  },
+  "dependencies": {
+    "vue-demi": "^0.14.10"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.1",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.2"
+  }
+}