@daweifu/capability-menu 0.1.0

package/lib/types/invoke.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Model-facing `meta_invoke` tool: unified execution/loading of capabilities.
+ *
+ * @module @daweifu/capability-menu (invoke plugin)
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+import { type SkillResourceBase } from '@deepseek-ai/dsh-skill';
+export declare const name = "capability-menu-invoke";
+export declare const inject: string[];
+/** Forwarding mode for the MCP branch. */
+export type MetaForwardMode = 'direct' | 'resolve';
+/** Model-facing `meta_invoke` configuration. */
+export interface Config {
+    /** How to forward MCP calls: `direct` executes via the tool pipeline; `resolve` returns the schema for the model to call directly. */
+    forwardMode?: MetaForwardMode;
+}
+/** Validate and default the tool configuration. */
+export declare const Config: z<Config>;
+/** Canonical MCP result shape. */
+export interface MetaInvokeMcpDetail {
+    readonly forwarded: true;
+    readonly target: string;
+    readonly content: ContentBlock[];
+}
+/** Canonical skill result shape (matches the `skill` tool output). */
+export interface MetaInvokeSkillDetail {
+    readonly name: string;
+    readonly provider: string;
+    readonly resourceBase?: SkillResourceBase;
+    readonly content: string;
+}
+/** Canonical resolve-mode result shape (forwardMode: 'resolve'). */
+export interface MetaInvokeResolveDetail {
+    readonly target: string;
+    readonly kind: string;
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: unknown;
+}
+/** Discriminated canonical result. */
+export type MetaInvokeResult = {
+    ok: true;
+    kind: 'mcp';
+    id: string;
+    detail: MetaInvokeMcpDetail;
+} | {
+    ok: true;
+    kind: 'skill';
+    id: string;
+    detail: MetaInvokeSkillDetail;
+} | {
+    ok: true;
+    kind: 'resolve';
+    id: string;
+    detail: MetaInvokeResolveDetail;
+};
+/**
+ * Register the `meta_invoke` tool.
+ *
+ * Dispatch is by `capability.kind`, not by id prefix (the id-prefix check is
+ * kept only as a defensive guard alongside the kind check).
+ *
+ * - Tools (`kind: 'tool'`, id `mcp__...`): forwards to the underlying server
+ *   call via the official `ctx.tools.execute` pipeline, preserving
+ *   `agent`/`signal`/parent lineage. `forwardMode: 'resolve'` instead returns
+ *   the target schema so the model can call the tool directly.
+ * - Skills (`kind: 'skill'`, id `skill:<name>`): loads the full skill
+ *   instructions and returns them as `<skill_content>` — no args, no script
+ *   execution (matches the existing `skill` tool semantics).
+ */
+export declare function apply(ctx: Context, config?: Config): void;
+/**
+ * Strip leading YAML frontmatter (`---\n...\n---`) from a raw SKILL.md body,
+ * returning the remaining markdown. Falls back to the raw text when no
+ * frontmatter delimiter is present.
+ */
+export declare function stripFrontmatter(markdown: string): string;
+//# sourceMappingURL=invoke.d.ts.map

package/lib/types/policy.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Exposed / Progressive / Blocked capability projection policy for the DeepSeek
+ * Harness.
+ *
+ * @module @daweifu/capability-menu (policy plugin)
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { PromptAssembly } from '@deepseek-ai/dsh-system-prompt';
+import { type CapabilityKind } from './registry.ts';
+/**
+ * Canonical policy classes, mirroring the registry's `CapabilityKind`.
+ *
+ * - `exposed`: the capability is on the dsh-native exposure surface — tools in
+ *   `assembly.tools` (the request `tools` payload), skills in the
+ *   `<available_skills>` catalog — so the model can call/load it single-hop.
+ * - `progressive`: absent from the native surface but discoverable in the
+ *   persistent meta registry; the model reaches it via `meta_search` then
+ *   `meta_invoke` (catalog-resident, load/execute on demand).
+ * - `blocked`: neither exposed nor discoverable nor executable.
+ */
+export type CapabilityClass = 'exposed' | 'progressive' | 'blocked';
+/**
+ * A single classify rule: an exact name or a `*`-glob pattern.
+ * A pattern matches a capability id (`mcp__<server>__<raw>` / `skill:<name>`)
+ * or a server name (`server:<name>`).
+ */
+export interface PolicyRule {
+    /** Whether the rule is a literal exact name (`*` free) or a glob pattern. */
+    readonly wildcard: boolean;
+    /** The normalized pattern/literal this rule represents. */
+    readonly pattern: string;
+    /** When non-empty, this rule only applies to the given capability kind. */
+    readonly kind?: CapabilityKind;
+    /** When `'server'`, the pattern is matched against the server name only. */
+    readonly target: 'id' | 'server';
+}
+/**
+ * Per-kind explicit configuration. `exposed`/`progressive`/`blocked` are
+ * ordered lists of exact-name / glob rules. Empty lists mean "nothing
+ * explicitly classified", so the default (`exposed`) applies.
+ */
+export interface CapabilitySetConfig {
+    /** Explicitly-Exposed rule list (exact name or glob). */
+    exposed?: string[];
+    /** Explicitly-Progressive rule list (exact name or glob). */
+    progressive?: string[];
+    /** Explicitly-Blocked rule list (exact name or glob); wins over everything. */
+    blocked?: string[];
+}
+/** Exposed / Progressive / Blocked projection policy configuration. */
+export interface Config {
+    /** Tool classification: `tools.exposed` / `tools.progressive` / `tools.blocked`. */
+    tools?: CapabilitySetConfig;
+    /** Skill classification: `skills.exposed` / `skills.progressive` / `skills.blocked`. */
+    skills?: CapabilitySetConfig;
+    /**
+     * Tool names that are ALWAYS kept exposed and can never be classified
+     * Progressive or Blocked. Default `[meta_search, meta_invoke]`.
+     */
+    metaTools?: string[];
+    /**
+     * Optional path to a Progressive-skill catalog YAML (name + description +
+     * path). Consumed by the registry as an additional skill index source (see
+     * `@daweifu/capability-menu-registry` `progressiveSkillCatalog`).
+     */
+    progressiveSkillCatalog?: string;
+}
+/** Validate and default the policy configuration. */
+export declare const Config: z<Config>;
+export declare const DEFAULT_META_TOOLS: readonly ["meta_search", "meta_invoke"];
+/**
+ * Convert a user-facing rule string into a normalized {@link PolicyRule}.
+ * - `server:<name>` → server-targeted rule (`target: 'server'`).
+ * - `server:<name>:*` → server-targeted glob over that server's tools.
+ * - contains `*` → glob (target `id`).
+ * - otherwise → literal exact name.
+ */
+export declare function parseRule(rule: string): PolicyRule;
+/** Compile a `*`-glob into a RegExp (escaped, `*` → `.*`). */
+export declare function compileGlob(pattern: string): RegExp;
+/** A compiled rule set for one capability kind. */
+export interface CompiledCapabilityRules {
+    readonly exposed: readonly PolicyRule[];
+    readonly progressive: readonly PolicyRule[];
+    readonly blocked: readonly PolicyRule[];
+}
+/** Compile a {@link CapabilitySetConfig} into fast-matchable rules. */
+export declare function compileSet(set?: CapabilitySetConfig): CompiledCapabilityRules;
+/** Candidate fields a rule is matched against. */
+export interface MatchTarget {
+    /** Full capability id: `mcp__<server>__<raw>` or `skill:<name>`. */
+    readonly id: string;
+    /** Bare model-facing name (tool name or skill name without `skill:` prefix). */
+    readonly name: string;
+    /** Server name for tools; undefined for skills. */
+    readonly server?: string;
+    /** Capability kind. */
+    readonly kind: CapabilityKind;
+    /** Rule kind the candidates belong to (mirrors `kind` for tool/skill rule sets). */
+    readonly ruleKind: CapabilityKind;
+}
+/**
+ * Classify a capability against compiled rules. Priority (hit stops the walk):
+ * blocked-exact > blocked-wildcard > exposed-exact > exposed-wildcard >
+ * progressive-exact > progressive-wildcard > default (exposed). `blocked`
+ * is a control decision, so it beats an explicit `exposed` rule.
+ */
+export declare function classify(compiled: CompiledCapabilityRules, target: MatchTarget, metaTools?: ReadonlySet<string> | readonly string[]): CapabilityClass;
+/**
+ * One capability's classification, as surfaced to a management UI.
+ * `class` is the machine-facing value; `classLabel` is a human-friendly
+ * display that ties the residency strategy to the model-facing relationship.
+ */
+export interface CapabilityClassification {
+    readonly id: string;
+    readonly kind: CapabilityKind;
+    /** Model-facing name (tool name or skill bare name). */
+    readonly name: string;
+    /** MCP server for tools; undefined for skills. */
+    readonly server?: string;
+    readonly class: CapabilityClass;
+    /** Human-friendly display label for the classification. */
+    readonly classLabel: string;
+    /** True when this capability is a mandatory meta tool (always Exposed). */
+    readonly mandatory: boolean;
+}
+/**
+ * The `ctx.capabilityPolicy` service surface.
+ */
+export interface CapabilityPolicyService {
+    /** Classify a tool by its public name (`mcp__<server>__<raw>` or meta tool). */
+    classifyTool(name: string): CapabilityClass;
+    /** Classify a skill by its bare name. */
+    classifySkill(name: string): CapabilityClass;
+    /** True when a tool is Exposed (or a mandatory meta tool). */
+    isExposedTool(name: string): boolean;
+    /** True when a skill is Exposed. */
+    isExposedSkill(name: string): boolean;
+    /** True when a tool is Progressive. */
+    isProgressiveTool(name: string): boolean;
+    /** True when a skill is Progressive. */
+    isProgressiveSkill(name: string): boolean;
+    /** True when a tool is Blocked. */
+    isBlockedTool(name: string): boolean;
+    /** True when a skill is Blocked. */
+    isBlockedSkill(name: string): boolean;
+    /** True when a capability id (`mcp__...` / `skill:...`) is Blocked. */
+    isBlockedCapability(id: string): boolean;
+    /** Tool names that are always kept Exposed. */
+    metaTools(): readonly string[];
+    /** Resolve a capability's id (e.g. `skill:<name>`) to a class. */
+    classifyCapability(id: string): CapabilityClass;
+    /** Rules exposed for the registry/other consumers. */
+    toolRules(): CompiledCapabilityRules;
+    skillRules(): CompiledCapabilityRules;
+    /** Current (resolved) policy config. */
+    getConfig(): Config;
+    /** Replace a subset of the policy config and recompile rules immediately. */
+    updateConfig(partial: Partial<Config>): void;
+    /**
+     * Classify every capability currently indexed by `ctx.meta` (the registry
+     * sibling). Returns an empty array when the registry is not mounted.
+     */
+    classifyAll(): readonly CapabilityClassification[];
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        capabilityPolicy: CapabilityPolicyService;
+    }
+}
+/**
+ * Build the projection listener for one assembly: keep only Exposed tools plus
+ * the mandatory meta tools.
+ */
+export declare function projectAssemblyTools(assembly: PromptAssembly, service: CapabilityPolicyService): PromptAssembly;
+/** Build the policy plugin. */
+export declare const name = "capability-menu-policy";
+export declare const inject: string[];
+export declare function apply(ctx: Context, config?: Config): void;
+//# sourceMappingURL=policy.d.ts.map

package/lib/types/registry.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Unified capability catalog for the DeepSeek Harness.
+ *
+ * @module @daweifu/capability-menu (registry plugin)
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { ScopeKey } from '@deepseek-ai/dsh-scope';
+import type { JsonSchemaNode } from '@deepseek-ai/dsh-tools';
+/**
+ * Kinds of capability the catalog can hold.
+ * - `tool`:   action capability — executes a concrete action (an MCP tool).
+ * - `skill`:  action capability — loads the method/instructions for a task.
+ */
+export type CapabilityKind = 'tool' | 'skill';
+/**
+ * Stable invocation actions a capability can declare. Each kind maps to one
+ * canonical action; a new kind only deserves a new value here when it
+ * introduces a new action (not a new flavor of an existing one).
+ * `execute` = run the concrete action (an MCP tool, via `ctx.tools.execute`);
+ * `load`    = load the method/instructions (a skill).
+ */
+export type CapabilityAction = 'execute' | 'load';
+/** Stable identifier prefixes: MCP tools keep `mcp__...`, skills use `skill:<name>`. */
+export declare const SKILL_ID_PREFIX = "skill:";
+export declare const MCP_ID_PREFIX = "mcp__";
+/** Capability-stable origin metadata used by search filters and detail views. */
+export interface CapabilityOrigin {
+    /** Human/namespace label, e.g. `gongfeng` or `filesystem`. */
+    readonly provider: string;
+    /** MCP server name, present only for `kind: 'tool'`. */
+    readonly serverName?: string;
+    /** Local skill path, present only for `kind: 'skill'`. */
+    readonly path?: string;
+}
+/** Objective and subjective usage statistics, written back from `tools/result`. */
+export interface CapabilityStats {
+    readonly uses: number;
+    readonly successes: number;
+    readonly failures: number;
+    readonly totalMs: number;
+    readonly lastUsedAt?: number;
+}
+/** One indexed capability. */
+export interface CapabilityRecord {
+    /** Stable identifier: `mcp__<server>__<raw>` or `skill:<name>`. */
+    readonly id: string;
+    readonly kind: CapabilityKind;
+    /** The canonical invocation action(s) this capability exposes. */
+    readonly actions: readonly CapabilityAction[];
+    /** Model-facing name (the tool name or skill name without prefix). */
+    readonly name: string;
+    readonly description: string;
+    /** Skill-only extra routing guidance. */
+    readonly whenToUse?: string;
+    readonly origin: CapabilityOrigin;
+    /** Full parameter schema (MCP inputSchema / empty object for skills). */
+    readonly parameters: JsonSchemaNode;
+    readonly invocation: {
+        modelInvocable: boolean;
+        userInvocable: boolean;
+    };
+    readonly tags: readonly string[];
+    readonly stats: CapabilityStats;
+    /** Token-trimmed short description used by `meta_search` list mode. */
+    readonly summary: string;
+}
+/** Lightweight list-mode projection of one capability (no full schema). */
+export interface CapabilitySummary {
+    readonly id: string;
+    readonly kind: CapabilityKind;
+    readonly name: string;
+    readonly summary: string;
+    readonly server?: string;
+    readonly tags: readonly string[];
+    readonly success_rate?: number;
+    readonly uses: number;
+}
+/** Full detail projection, including the parameter schema. */
+export interface CapabilityDetail {
+    readonly id: string;
+    readonly kind: CapabilityKind;
+    readonly actions: readonly CapabilityAction[];
+    readonly name: string;
+    readonly description: string;
+    readonly whenToUse?: string;
+    readonly parameters: JsonSchemaNode;
+    readonly output?: JsonSchemaNode;
+    readonly origin: CapabilityOrigin;
+    readonly tags: readonly string[];
+    readonly stats: CapabilityStats;
+}
+/** Search filter options. */
+export interface MetaSearchOptions {
+    readonly kind?: CapabilityKind | 'all';
+    readonly server?: string | undefined;
+    readonly tag?: string | undefined;
+    /** Maximum number of results to return. */
+    readonly maxResults?: number;
+    /**
+     * Viewing scope. Retained for caller ergonomics and optional authorization
+     * checks, but the policy does NOT use it to filter visibility — Progressive
+     * capabilities must remain searchable regardless of the caller's projection.
+     */
+    readonly scope?: ScopeKey | undefined;
+    /** Query string for keyword matching; exact id/name match wins. */
+    readonly query?: string;
+    /** Exact capability id. */
+    readonly id?: string;
+    /** Whether to include the full body for skills in `getDetail` (default false). */
+    readonly detailIncludesBody?: boolean;
+}
+/** Runtime detail resolution context. */
+export interface MetaLookupContext {
+    readonly cwd?: string | undefined;
+    readonly signal?: AbortSignal | undefined;
+    readonly scope?: ScopeKey | undefined;
+}
+/** One direct child in a skill directory listing. */
+export interface SkillDirEntry {
+    readonly name: string;
+    readonly type: 'file' | 'directory';
+}
+/** The `ctx.meta` service surface. */
+export interface MetaService {
+    /** Enumerate the current catalog (optionally filtered). */
+    search(options?: MetaSearchOptions): CapabilitySummary[];
+    /** Resolve one record by id, or undefined. */
+    get(id: string): CapabilityRecord | undefined;
+    /** Resolve one record's full detail (schema, output; skill body optional). */
+    getDetail(id: string, context?: MetaLookupContext): Promise<CapabilityDetail | undefined>;
+    /**
+     * List a skill's directory children (one level deep). The directory is
+     * resolved from the skill's own provider path, never from caller input;
+     * `relPath` (optional, relative to the skill root) descends into a child
+     * directory.
+     */
+    listSkillDir(id: string, relPath?: string): Promise<SkillDirEntry[] | undefined>;
+    /**
+     * Read a text file inside a skill's directory, addressed by a relative path
+     * that is resolved against and confined to the skill root. Binary files
+     * (content containing NUL) return undefined.
+     */
+    readSkillFile(id: string, relPath: string): Promise<string | undefined>;
+    /** Return the current number of indexed capabilities. */
+    size(): number;
+    /**
+     * Rebuild the catalog from the current tool/skill registries; resolves when
+     * done. In production the registry rebuilds automatically on `tools/change`
+     * / `skills/change`; this public handle is for tests and external orchestrators
+     * that want to force a rebuild (e.g. after a `progressiveSkillCatalog` change).
+     */
+    refresh(): Promise<void>;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        meta: MetaService;
+    }
+}
+/** Registry configuration. */
+export interface Config {
+    /** Maximum summary length in characters (min 20). */
+    summaryMaxChars?: number;
+    /** Whether to include the skill body in `getDetail` results (default false). */
+    detailIncludesBody?: boolean;
+    /** Maximum search results returned (default 20, max 100). */
+    maxResults?: number;
+    /** Experience-weighting intensity for ranking (0 disables, default 0.1). */
+    weighting?: number;
+    /**
+     * Optional path to a Progressive-skill catalog YAML (see §7.2). Each entry
+     * `{ name, description, whenToUse?, path? }` is indexed as a `skill`
+     * CapabilityRecord so `meta_search(kind=skill)` can find Progressive skills
+     * that are not otherwise registered in the session skill registry. The full
+     * SKILL.md is loaded on demand by `meta_invoke` (see the invoke package).
+     */
+    progressiveSkillCatalog?: string;
+}
+/** Validate and default the registry configuration. */
+export declare const Config: z<Config>;
+/** Build the registry plugin. */
+export declare const name = "capability-menu-registry";
+export declare const inject: string[];
+export declare function apply(ctx: Context, config?: Config): void;
+/** Derive the server namespace from an `mcp__<server>__<raw>` name. */
+export declare function serverNameOf(publicName: string): string;
+/** Build the stable skill identifier `skill:<name>`. */
+export declare function skillId(name: string): string;
+/** Strip the `skill:` prefix from a capability id. */
+export declare function skillNameOf(id: string): string;
+//# sourceMappingURL=registry.d.ts.map

package/lib/types/search.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Model-facing `meta_search` tool: capability catalog search + detail.
+ *
+ * @module @daweifu/capability-menu (search plugin)
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { CapabilityDetail, CapabilitySummary } from './registry.ts';
+export declare const name = "capability-menu-search";
+export declare const inject: string[];
+/** Model-facing `meta_search` configuration. */
+export interface Config {
+    /** Maximum results returned in list mode (default 20). */
+    maxResults?: number;
+}
+/** Validate and default the tool configuration. */
+export declare const Config: z<Config>;
+/** Canonical list-mode result. */
+export interface MetaSearchListResult {
+    readonly mode: 'list';
+    readonly total: number;
+    readonly results: CapabilitySummary[];
+    readonly hint: string;
+}
+/** Canonical detail-mode result. */
+export interface MetaSearchDetailResult {
+    readonly mode: 'detail';
+    readonly result: CapabilityDetail;
+}
+/** Canonical tool result: one of the two modes. */
+export type MetaSearchResult = MetaSearchListResult | MetaSearchDetailResult;
+/**
+ * Register the `meta_search` tool.
+ *
+ * - Mode A (list, default): query by keyword/tag/server, returns id + short summary.
+ * - Mode B (detail): pass an exact id (optionally `detail: true`) to get the full schema.
+ *
+ * Validation rules enforced here:
+ * - `query` and `id` are mutually exclusive.
+ * - `detail: true` with a fuzzy query (no exact id) is rejected.
+ */
+export declare function apply(ctx: Context, config?: Config): void;
+//# sourceMappingURL=search.d.ts.map

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@daweifu/capability-menu",
+  "version": "0.1.0",
+  "description": "Unified capability management for the DeepSeek Harness: catalog (registry) + meta_search/meta_invoke + Exposed/Progressive/Blocked projection policy + 能力管理 surface, in one installable bundle.",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "prepare": "npm run build"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./registry": {
+      "types": "./lib/types/registry.d.ts",
+      "default": "./lib/registry.js"
+    },
+    "./search": {
+      "types": "./lib/types/search.d.ts",
+      "default": "./lib/search.js"
+    },
+    "./invoke": {
+      "types": "./lib/types/invoke.d.ts",
+      "default": "./lib/invoke.js"
+    },
+    "./policy": {
+      "types": "./lib/types/policy.d.ts",
+      "default": "./lib/policy.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/registry.js",
+    "lib/search.js",
+    "lib/invoke.js",
+    "lib/policy.js",
+    "lib/invariant.js",
+    "cordis.patch.yml",
+    "lib/types/**/*.d.ts"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-scope": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-skill": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.7",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-skill-filesystem": "^0.1.0-rc.7",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.0.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  }
+}