@versatly/workgraph 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,419 @@
+/**
+ * Workgraph type definitions.
+ */
+interface FieldDefinition {
+    type: 'string' | 'number' | 'boolean' | 'list' | 'date' | 'ref' | 'any';
+    required?: boolean;
+    default?: unknown;
+    description?: string;
+}
+interface PrimitiveTypeDefinition {
+    name: string;
+    description: string;
+    fields: Record<string, FieldDefinition>;
+    /** Directory under workspace root where instances live (default: `<name>s/`). */
+    directory: string;
+    /** Whether this type was defined by an agent at runtime vs built-in. */
+    builtIn: boolean;
+    /** ISO timestamp of when this type was registered. */
+    createdAt: string;
+    /** Who registered it (agent name or "system"). */
+    createdBy: string;
+}
+interface Registry {
+    version: number;
+    types: Record<string, PrimitiveTypeDefinition>;
+}
+type LedgerOp = 'create' | 'update' | 'delete' | 'claim' | 'release' | 'block' | 'unblock' | 'done' | 'cancel' | 'define' | 'decompose';
+interface LedgerEntry {
+    ts: string;
+    actor: string;
+    op: LedgerOp;
+    target: string;
+    type?: string;
+    data?: Record<string, unknown>;
+    prevHash?: string;
+    hash?: string;
+}
+interface LedgerIndex {
+    version: number;
+    lastEntryTs: string;
+    claims: Record<string, string>;
+}
+interface LedgerChainState {
+    version: number;
+    algorithm: 'sha256';
+    lastHash: string;
+    count: number;
+    updatedAt: string;
+}
+type ThreadStatus = 'open' | 'active' | 'blocked' | 'done' | 'cancelled';
+declare const THREAD_STATUS_TRANSITIONS: Record<ThreadStatus, ThreadStatus[]>;
+interface PrimitiveInstance {
+    /** File path relative to workspace root. */
+    path: string;
+    /** Primitive type name. */
+    type: string;
+    /** Frontmatter fields. */
+    fields: Record<string, unknown>;
+    /** Markdown body content. */
+    body: string;
+}
+interface WorkgraphWorkspaceConfig {
+    name: string;
+    version: string;
+    mode: 'workgraph';
+    createdAt: string;
+    updatedAt: string;
+}
+
+/**
+ * Dynamic primitive type registry.
+ */
+
+declare function registryPath(workspacePath: string): string;
+declare function loadRegistry(workspacePath: string): Registry;
+declare function saveRegistry(workspacePath: string, registry: Registry): void;
+declare function defineType(workspacePath: string, name: string, description: string, fields: Record<string, FieldDefinition>, actor: string, directory?: string): PrimitiveTypeDefinition;
+declare function getType(workspacePath: string, name: string): PrimitiveTypeDefinition | undefined;
+declare function listTypes(workspacePath: string): PrimitiveTypeDefinition[];
+declare function extendType(workspacePath: string, name: string, newFields: Record<string, FieldDefinition>, _actor: string): PrimitiveTypeDefinition;
+
+declare const registry_defineType: typeof defineType;
+declare const registry_extendType: typeof extendType;
+declare const registry_getType: typeof getType;
+declare const registry_listTypes: typeof listTypes;
+declare const registry_loadRegistry: typeof loadRegistry;
+declare const registry_registryPath: typeof registryPath;
+declare const registry_saveRegistry: typeof saveRegistry;
+declare namespace registry {
+  export { registry_defineType as defineType, registry_extendType as extendType, registry_getType as getType, registry_listTypes as listTypes, registry_loadRegistry as loadRegistry, registry_registryPath as registryPath, registry_saveRegistry as saveRegistry };
+}
+
+/**
+ * Append-only event ledger.
+ *
+ * Format: one JSON object per line (.jsonl) in `.clawvault/ledger.jsonl`.
+ */
+
+declare function ledgerPath(workspacePath: string): string;
+declare function ledgerIndexPath(workspacePath: string): string;
+declare function ledgerChainStatePath(workspacePath: string): string;
+declare function append(workspacePath: string, actor: string, op: LedgerOp, target: string, type?: string, data?: Record<string, unknown>): LedgerEntry;
+declare function readAll(workspacePath: string): LedgerEntry[];
+declare function readSince(workspacePath: string, since: string): LedgerEntry[];
+declare function loadIndex(workspacePath: string): LedgerIndex | null;
+declare function loadChainState(workspacePath: string): LedgerChainState | null;
+declare function rebuildIndex(workspacePath: string): LedgerIndex;
+declare function rebuildHashChainState(workspacePath: string): LedgerChainState;
+declare function claimsFromIndex(workspacePath: string): Map<string, string>;
+interface LedgerQueryOptions {
+    actor?: string;
+    op?: LedgerOp;
+    target?: string;
+    targetIncludes?: string;
+    type?: string;
+    since?: string;
+    until?: string;
+    limit?: number;
+    offset?: number;
+}
+declare function query(workspacePath: string, options?: LedgerQueryOptions): LedgerEntry[];
+interface LedgerBlameActorSummary {
+    actor: string;
+    count: number;
+    ops: Record<string, number>;
+    lastTs: string;
+}
+interface LedgerBlameResult {
+    target: string;
+    totalEntries: number;
+    actors: LedgerBlameActorSummary[];
+    latest: LedgerEntry | null;
+}
+declare function blame(workspacePath: string, target: string): LedgerBlameResult;
+interface LedgerVerifyOptions {
+    strict?: boolean;
+}
+interface LedgerVerifyResult {
+    ok: boolean;
+    entries: number;
+    lastHash: string;
+    issues: string[];
+    warnings: string[];
+    chainState: LedgerChainState | null;
+}
+declare function verifyHashChain(workspacePath: string, options?: LedgerVerifyOptions): LedgerVerifyResult;
+/** Get the current owner of a target (last claim without a subsequent release/done). */
+declare function currentOwner(workspacePath: string, target: string): string | null;
+/** Check if a target is currently claimed by any agent. */
+declare function isClaimed(workspacePath: string, target: string): boolean;
+/** Get all entries for a specific target. */
+declare function historyOf(workspacePath: string, target: string): LedgerEntry[];
+/** Get all entries by a specific actor. */
+declare function activityOf(workspacePath: string, actor: string): LedgerEntry[];
+/** Get all currently claimed targets and their owners. */
+declare function allClaims(workspacePath: string): Map<string, string>;
+/** Get recent ledger entries (last N). */
+declare function recent(workspacePath: string, count?: number): LedgerEntry[];
+
+type ledger_LedgerBlameActorSummary = LedgerBlameActorSummary;
+type ledger_LedgerBlameResult = LedgerBlameResult;
+type ledger_LedgerQueryOptions = LedgerQueryOptions;
+type ledger_LedgerVerifyOptions = LedgerVerifyOptions;
+type ledger_LedgerVerifyResult = LedgerVerifyResult;
+declare const ledger_activityOf: typeof activityOf;
+declare const ledger_allClaims: typeof allClaims;
+declare const ledger_append: typeof append;
+declare const ledger_blame: typeof blame;
+declare const ledger_claimsFromIndex: typeof claimsFromIndex;
+declare const ledger_currentOwner: typeof currentOwner;
+declare const ledger_historyOf: typeof historyOf;
+declare const ledger_isClaimed: typeof isClaimed;
+declare const ledger_ledgerChainStatePath: typeof ledgerChainStatePath;
+declare const ledger_ledgerIndexPath: typeof ledgerIndexPath;
+declare const ledger_ledgerPath: typeof ledgerPath;
+declare const ledger_loadChainState: typeof loadChainState;
+declare const ledger_loadIndex: typeof loadIndex;
+declare const ledger_query: typeof query;
+declare const ledger_readAll: typeof readAll;
+declare const ledger_readSince: typeof readSince;
+declare const ledger_rebuildHashChainState: typeof rebuildHashChainState;
+declare const ledger_rebuildIndex: typeof rebuildIndex;
+declare const ledger_recent: typeof recent;
+declare const ledger_verifyHashChain: typeof verifyHashChain;
+declare namespace ledger {
+  export { type ledger_LedgerBlameActorSummary as LedgerBlameActorSummary, type ledger_LedgerBlameResult as LedgerBlameResult, type ledger_LedgerQueryOptions as LedgerQueryOptions, type ledger_LedgerVerifyOptions as LedgerVerifyOptions, type ledger_LedgerVerifyResult as LedgerVerifyResult, ledger_activityOf as activityOf, ledger_allClaims as allClaims, ledger_append as append, ledger_blame as blame, ledger_claimsFromIndex as claimsFromIndex, ledger_currentOwner as currentOwner, ledger_historyOf as historyOf, ledger_isClaimed as isClaimed, ledger_ledgerChainStatePath as ledgerChainStatePath, ledger_ledgerIndexPath as ledgerIndexPath, ledger_ledgerPath as ledgerPath, ledger_loadChainState as loadChainState, ledger_loadIndex as loadIndex, ledger_query as query, ledger_readAll as readAll, ledger_readSince as readSince, ledger_rebuildHashChainState as rebuildHashChainState, ledger_rebuildIndex as rebuildIndex, ledger_recent as recent, ledger_verifyHashChain as verifyHashChain };
+}
+
+/**
+ * Workgraph store — CRUD for primitive instances.
+ */
+
+declare function create(workspacePath: string, typeName: string, fields: Record<string, unknown>, body: string, actor: string): PrimitiveInstance;
+declare function read(workspacePath: string, relPath: string): PrimitiveInstance | null;
+declare function list(workspacePath: string, typeName: string): PrimitiveInstance[];
+declare function update(workspacePath: string, relPath: string, fieldUpdates: Record<string, unknown>, bodyUpdate: string | undefined, actor: string): PrimitiveInstance;
+declare function remove(workspacePath: string, relPath: string, actor: string): void;
+declare function findByField(workspacePath: string, typeName: string, field: string, value: unknown): PrimitiveInstance[];
+declare function openThreads(workspacePath: string): PrimitiveInstance[];
+declare function activeThreads(workspacePath: string): PrimitiveInstance[];
+declare function blockedThreads(workspacePath: string): PrimitiveInstance[];
+declare function threadsInSpace(workspacePath: string, spaceRef: string): PrimitiveInstance[];
+
+declare const store_activeThreads: typeof activeThreads;
+declare const store_blockedThreads: typeof blockedThreads;
+declare const store_create: typeof create;
+declare const store_findByField: typeof findByField;
+declare const store_list: typeof list;
+declare const store_openThreads: typeof openThreads;
+declare const store_read: typeof read;
+declare const store_remove: typeof remove;
+declare const store_threadsInSpace: typeof threadsInSpace;
+declare const store_update: typeof update;
+declare namespace store {
+  export { store_activeThreads as activeThreads, store_blockedThreads as blockedThreads, store_create as create, store_findByField as findByField, store_list as list, store_openThreads as openThreads, store_read as read, store_remove as remove, store_threadsInSpace as threadsInSpace, store_update as update };
+}
+
+/**
+ * Thread lifecycle operations.
+ */
+
+declare function createThread(workspacePath: string, title: string, goal: string, actor: string, opts?: {
+    priority?: string;
+    deps?: string[];
+    parent?: string;
+    space?: string;
+    context_refs?: string[];
+    tags?: string[];
+}): PrimitiveInstance;
+declare function isReadyForClaim(workspacePath: string, threadPathOrInstance: string | PrimitiveInstance): boolean;
+declare function listReadyThreads(workspacePath: string): PrimitiveInstance[];
+declare function listReadyThreadsInSpace(workspacePath: string, spaceRef: string): PrimitiveInstance[];
+declare function pickNextReadyThread(workspacePath: string): PrimitiveInstance | null;
+declare function pickNextReadyThreadInSpace(workspacePath: string, spaceRef: string): PrimitiveInstance | null;
+declare function claimNextReady(workspacePath: string, actor: string): PrimitiveInstance | null;
+declare function claimNextReadyInSpace(workspacePath: string, actor: string, spaceRef: string): PrimitiveInstance | null;
+declare function claim(workspacePath: string, threadPath: string, actor: string): PrimitiveInstance;
+declare function release(workspacePath: string, threadPath: string, actor: string, reason?: string): PrimitiveInstance;
+declare function block(workspacePath: string, threadPath: string, actor: string, blockedBy: string, reason?: string): PrimitiveInstance;
+declare function unblock(workspacePath: string, threadPath: string, actor: string): PrimitiveInstance;
+declare function done(workspacePath: string, threadPath: string, actor: string, output?: string): PrimitiveInstance;
+declare function cancel(workspacePath: string, threadPath: string, actor: string, reason?: string): PrimitiveInstance;
+declare function decompose(workspacePath: string, parentPath: string, subthreads: Array<{
+    title: string;
+    goal: string;
+    deps?: string[];
+}>, actor: string): PrimitiveInstance[];
+
+declare const thread_block: typeof block;
+declare const thread_cancel: typeof cancel;
+declare const thread_claim: typeof claim;
+declare const thread_claimNextReady: typeof claimNextReady;
+declare const thread_claimNextReadyInSpace: typeof claimNextReadyInSpace;
+declare const thread_createThread: typeof createThread;
+declare const thread_decompose: typeof decompose;
+declare const thread_done: typeof done;
+declare const thread_isReadyForClaim: typeof isReadyForClaim;
+declare const thread_listReadyThreads: typeof listReadyThreads;
+declare const thread_listReadyThreadsInSpace: typeof listReadyThreadsInSpace;
+declare const thread_pickNextReadyThread: typeof pickNextReadyThread;
+declare const thread_pickNextReadyThreadInSpace: typeof pickNextReadyThreadInSpace;
+declare const thread_release: typeof release;
+declare const thread_unblock: typeof unblock;
+declare namespace thread {
+  export { thread_block as block, thread_cancel as cancel, thread_claim as claim, thread_claimNextReady as claimNextReady, thread_claimNextReadyInSpace as claimNextReadyInSpace, thread_createThread as createThread, thread_decompose as decompose, thread_done as done, thread_isReadyForClaim as isReadyForClaim, thread_listReadyThreads as listReadyThreads, thread_listReadyThreadsInSpace as listReadyThreadsInSpace, thread_pickNextReadyThread as pickNextReadyThread, thread_pickNextReadyThreadInSpace as pickNextReadyThreadInSpace, thread_release as release, thread_unblock as unblock };
+}
+
+/**
+ * Workgraph workspace lifecycle (agent-first, no memory scaffolding).
+ */
+
+interface InitWorkspaceOptions {
+    name?: string;
+    createTypeDirs?: boolean;
+    createReadme?: boolean;
+    createBases?: boolean;
+}
+interface InitWorkspaceResult {
+    workspacePath: string;
+    configPath: string;
+    config: WorkgraphWorkspaceConfig;
+    createdDirectories: string[];
+    seededTypes: string[];
+    generatedBases: string[];
+    primitiveRegistryManifestPath: string;
+}
+declare function workspaceConfigPath(workspacePath: string): string;
+declare function isWorkgraphWorkspace(workspacePath: string): boolean;
+declare function initWorkspace(targetPath: string, options?: InitWorkspaceOptions): InitWorkspaceResult;
+
+type workspace_InitWorkspaceOptions = InitWorkspaceOptions;
+type workspace_InitWorkspaceResult = InitWorkspaceResult;
+declare const workspace_initWorkspace: typeof initWorkspace;
+declare const workspace_isWorkgraphWorkspace: typeof isWorkgraphWorkspace;
+declare const workspace_workspaceConfigPath: typeof workspaceConfigPath;
+declare namespace workspace {
+  export { type workspace_InitWorkspaceOptions as InitWorkspaceOptions, type workspace_InitWorkspaceResult as InitWorkspaceResult, workspace_initWorkspace as initWorkspace, workspace_isWorkgraphWorkspace as isWorkgraphWorkspace, workspace_workspaceConfigPath as workspaceConfigPath };
+}
+
+/**
+ * Command center generator for human + agent operational visibility.
+ */
+interface CommandCenterOptions {
+    outputPath?: string;
+    actor?: string;
+    recentCount?: number;
+}
+interface CommandCenterResult {
+    outputPath: string;
+    stats: {
+        totalThreads: number;
+        openThreads: number;
+        activeThreads: number;
+        blockedThreads: number;
+        doneThreads: number;
+        activeClaims: number;
+        recentEvents: number;
+    };
+    content: string;
+}
+declare function generateCommandCenter(workspacePath: string, options?: CommandCenterOptions): CommandCenterResult;
+
+type commandCenter_CommandCenterOptions = CommandCenterOptions;
+type commandCenter_CommandCenterResult = CommandCenterResult;
+declare const commandCenter_generateCommandCenter: typeof generateCommandCenter;
+declare namespace commandCenter {
+  export { type commandCenter_CommandCenterOptions as CommandCenterOptions, type commandCenter_CommandCenterResult as CommandCenterResult, commandCenter_generateCommandCenter as generateCommandCenter };
+}
+
+/**
+ * Primitive registry manifest + Obsidian Bases generation.
+ */
+interface PrimitiveRegistryManifestField {
+    name: string;
+    type: string;
+    required?: boolean;
+    description?: string;
+}
+interface PrimitiveRegistryManifestPrimitive {
+    name: string;
+    directory: string;
+    canonical: boolean;
+    builtIn: boolean;
+    fields: PrimitiveRegistryManifestField[];
+}
+interface PrimitiveRegistryManifest {
+    version: number;
+    generatedAt: string;
+    primitives: PrimitiveRegistryManifestPrimitive[];
+}
+interface GenerateBasesOptions {
+    includeNonCanonical?: boolean;
+    outputDirectory?: string;
+}
+interface GenerateBasesResult {
+    outputDirectory: string;
+    generated: string[];
+}
+declare function primitiveRegistryManifestPath(workspacePath: string): string;
+declare function readPrimitiveRegistryManifest(workspacePath: string): PrimitiveRegistryManifest;
+declare function syncPrimitiveRegistryManifest(workspacePath: string): PrimitiveRegistryManifest;
+declare function generateBasesFromPrimitiveRegistry(workspacePath: string, options?: GenerateBasesOptions): GenerateBasesResult;
+
+type bases_GenerateBasesOptions = GenerateBasesOptions;
+type bases_GenerateBasesResult = GenerateBasesResult;
+type bases_PrimitiveRegistryManifest = PrimitiveRegistryManifest;
+type bases_PrimitiveRegistryManifestField = PrimitiveRegistryManifestField;
+type bases_PrimitiveRegistryManifestPrimitive = PrimitiveRegistryManifestPrimitive;
+declare const bases_generateBasesFromPrimitiveRegistry: typeof generateBasesFromPrimitiveRegistry;
+declare const bases_primitiveRegistryManifestPath: typeof primitiveRegistryManifestPath;
+declare const bases_readPrimitiveRegistryManifest: typeof readPrimitiveRegistryManifest;
+declare const bases_syncPrimitiveRegistryManifest: typeof syncPrimitiveRegistryManifest;
+declare namespace bases {
+  export { type bases_GenerateBasesOptions as GenerateBasesOptions, type bases_GenerateBasesResult as GenerateBasesResult, type bases_PrimitiveRegistryManifest as PrimitiveRegistryManifest, type bases_PrimitiveRegistryManifestField as PrimitiveRegistryManifestField, type bases_PrimitiveRegistryManifestPrimitive as PrimitiveRegistryManifestPrimitive, bases_generateBasesFromPrimitiveRegistry as generateBasesFromPrimitiveRegistry, bases_primitiveRegistryManifestPath as primitiveRegistryManifestPath, bases_readPrimitiveRegistryManifest as readPrimitiveRegistryManifest, bases_syncPrimitiveRegistryManifest as syncPrimitiveRegistryManifest };
+}
+
+/**
+ * Skill primitive lifecycle.
+ */
+
+interface WriteSkillOptions {
+    owner?: string;
+    version?: string;
+    status?: 'draft' | 'proposed' | 'active' | 'deprecated' | 'archived';
+    distribution?: string;
+    tailscalePath?: string;
+    reviewers?: string[];
+    tags?: string[];
+}
+interface ProposeSkillOptions {
+    proposalThread?: string;
+    createThreadIfMissing?: boolean;
+    space?: string;
+    reviewers?: string[];
+}
+interface PromoteSkillOptions {
+    version?: string;
+}
+declare function writeSkill(workspacePath: string, title: string, body: string, actor: string, options?: WriteSkillOptions): PrimitiveInstance;
+declare function loadSkill(workspacePath: string, skillRef: string): PrimitiveInstance;
+declare function listSkills(workspacePath: string, options?: {
+    status?: string;
+}): PrimitiveInstance[];
+declare function proposeSkill(workspacePath: string, skillRef: string, actor: string, options?: ProposeSkillOptions): PrimitiveInstance;
+declare function promoteSkill(workspacePath: string, skillRef: string, actor: string, options?: PromoteSkillOptions): PrimitiveInstance;
+
+type skill_PromoteSkillOptions = PromoteSkillOptions;
+type skill_ProposeSkillOptions = ProposeSkillOptions;
+type skill_WriteSkillOptions = WriteSkillOptions;
+declare const skill_listSkills: typeof listSkills;
+declare const skill_loadSkill: typeof loadSkill;
+declare const skill_promoteSkill: typeof promoteSkill;
+declare const skill_proposeSkill: typeof proposeSkill;
+declare const skill_writeSkill: typeof writeSkill;
+declare namespace skill {
+  export { type skill_PromoteSkillOptions as PromoteSkillOptions, type skill_ProposeSkillOptions as ProposeSkillOptions, type skill_WriteSkillOptions as WriteSkillOptions, skill_listSkills as listSkills, skill_loadSkill as loadSkill, skill_promoteSkill as promoteSkill, skill_proposeSkill as proposeSkill, skill_writeSkill as writeSkill };
+}
+
+export { type FieldDefinition, type LedgerChainState, type LedgerEntry, type LedgerIndex, type LedgerOp, type PrimitiveInstance, type PrimitiveTypeDefinition, type Registry, THREAD_STATUS_TRANSITIONS, type ThreadStatus, type WorkgraphWorkspaceConfig, bases, commandCenter, ledger, registry, skill, store, thread, workspace };

package/dist/index.js

@@ -0,0 +1,22 @@
+import {
+  THREAD_STATUS_TRANSITIONS,
+  bases_exports,
+  command_center_exports,
+  ledger_exports,
+  registry_exports,
+  skill_exports,
+  store_exports,
+  thread_exports,
+  workspace_exports
+} from "./chunk-CRQXDCPR.js";
+export {
+  THREAD_STATUS_TRANSITIONS,
+  bases_exports as bases,
+  command_center_exports as commandCenter,
+  ledger_exports as ledger,
+  registry_exports as registry,
+  skill_exports as skill,
+  store_exports as store,
+  thread_exports as thread,
+  workspace_exports as workspace
+};

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@versatly/workgraph",
+  "version": "0.1.0",
+  "description": "Agent-first workgraph workspace for multi-agent coordination with dynamic primitives, append-only ledger, and markdown-native storage.",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.ts",
+      "import": "./dist/cli.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "workgraph": "bin/workgraph.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md",
+    "SKILL.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --config vitest.config.ts",
+    "ci": "npm run typecheck && npm run test && npm run build",
+    "prepublishOnly": "npm run ci"
+  },
+  "keywords": [
+    "workgraph",
+    "multi-agent",
+    "agent-coordination",
+    "ledger",
+    "markdown",
+    "primitives"
+  ],
+  "author": "Versatly",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Versatly/clawvault.git",
+    "directory": "packages/workgraph"
+  },
+  "homepage": "https://github.com/Versatly/clawvault/tree/main/packages/workgraph",
+  "bugs": {
+    "url": "https://github.com/Versatly/clawvault/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "gray-matter": "^4.0.3",
+    "yaml": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.6.1"
+  }
+}