agentic-canvas 0.0.0-stage → 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+import {
+  ActorConfigError,
+  BRAND,
+  CanvasError,
+  CanvasService,
+  operatorActor,
+  runMcp
+} from "./chunk-NSZ2AC5O.js";
+import {
+  openLocalStore
+} from "./chunk-I3EJ5JB7.js";
+
+// src/cli.ts
+import { readFileSync, writeFileSync } from "fs";
+import { parseArgs } from "util";
+var UsageError = class extends Error {
+};
+var HELP = `${BRAND.command} ${BRAND.version}
+${BRAND.description}
+
+Usage: ${BRAND.command} [--dir <path>] <command> [flags]
+
+Commands:
+  new [--id <id>] [--title <t>]            Make a board.
+  read <board>                             Print the board as JSON.
+  add <board> --type <t> --x <n> --y <n>   Add a shape. Also: --w --h --text --fill --stroke --src --id.
+  connect <board> <from> <to> [--text <t>] Join two shapes with an arrow.
+  move <board> <element> --dx <n> --dy <n> Move an element or a group.
+  rm <board> <element>                     Delete an element.
+  flow <board> --text <t> | --file <p>     Draw a flowchart from text ("A -> B: label"). Use --file - for stdin.
+  export <board> [--format svg|png] [--out <path>]  Print SVG, or write PNG to --out.
+  repair <board> [--drop <element>]...     Owner only: fix a broken or over-cap board. Needs CANVAS_ACTOR=human:<id>.
+  mcp                                      Serve these as MCP tools on stdio. Needs CANVAS_ACTOR.
+
+Write commands need an actor in CANVAS_ACTOR as <kind>:<id>, such as "agent:helper".
+The operator sets it. A caller cannot pick its own kind: there is no --actor flag.
+Kinds: human, agent_of_human, agent_of_agent, agent, user_token.
+The store folder is --dir, or CANVAS_DIR, or ./.agentic-canvas.`;
+var flags = {
+  dir: { type: "string" },
+  id: { type: "string" },
+  title: { type: "string" },
+  type: { type: "string" },
+  x: { type: "string" },
+  y: { type: "string" },
+  w: { type: "string" },
+  h: { type: "string" },
+  text: { type: "string" },
+  fill: { type: "string" },
+  stroke: { type: "string" },
+  src: { type: "string" },
+  dx: { type: "string" },
+  dy: { type: "string" },
+  file: { type: "string" },
+  prefix: { type: "string" },
+  format: { type: "string" },
+  out: { type: "string" },
+  drop: { type: "string", multiple: true },
+  help: { type: "boolean" },
+  version: { type: "boolean" }
+};
+var num = (v) => v === void 0 ? void 0 : v.trim() === "" ? Number.NaN : Number(v);
+function joinNegatives(argv) {
+  const out = [];
+  for (let i = 0; i < argv.length; i++) {
+    const next = argv[i + 1] ?? "";
+    if (argv[i].startsWith("--") && !argv[i].includes("=") && /^-\d/.test(next)) out.push(`${argv[i]}=${argv[++i]}`);
+    else out.push(argv[i]);
+  }
+  return out;
+}
+async function run(argv) {
+  const { values: v, positionals } = parseArgs({ args: joinNegatives(argv), options: flags, allowPositionals: true });
+  if (v.version) return void console.log(BRAND.version);
+  const [command, board, ...rest] = positionals;
+  if (v.help || command === void 0) return void console.log(HELP);
+  const need = (count, shape) => {
+    if (positionals.length !== count + 1) throw new UsageError(`usage: ${BRAND.command} ${command} ${shape}`);
+  };
+  const actor = () => {
+    try {
+      return operatorActor();
+    } catch (error) {
+      if (error instanceof ActorConfigError) throw new UsageError(`"${command}" needs an actor: ${error.message}`);
+      throw error;
+    }
+  };
+  const service = new CanvasService(openLocalStore(v.dir ?? process.env.CANVAS_DIR ?? ".agentic-canvas"));
+  const print = (value) => console.log(JSON.stringify(value));
+  switch (command) {
+    case "new":
+      need(0, "[--id <id>] [--title <t>]");
+      return print(await service.create(actor(), { id: v.id, title: v.title }));
+    case "read":
+      need(1, "<board>");
+      return print(await service.read(board));
+    case "add":
+      need(1, "<board> --type <t> --x <n> --y <n>");
+      return print(await service.add(board, { id: v.id, type: v.type, x: num(v.x), y: num(v.y), w: num(v.w), h: num(v.h), text: v.text, fill: v.fill, stroke: v.stroke, src: v.src }, actor()));
+    case "connect":
+      need(3, "<board> <from> <to> [--text <t>]");
+      return print(await service.connect(board, { id: v.id, from: { id: rest[0] }, to: { id: rest[1] }, text: v.text }, actor()));
+    case "move":
+      need(2, "<board> <element> --dx <n> --dy <n>");
+      return print(await service.move(board, rest[0], num(v.dx) ?? Number.NaN, num(v.dy) ?? Number.NaN, actor()));
+    case "rm":
+      need(2, "<board> <element>");
+      return print(await service.remove(board, rest[0]));
+    case "flow": {
+      need(1, "<board> --text <t> | --file <path>");
+      if (v.text === void 0 === (v.file === void 0)) throw new UsageError("flow needs exactly one of --text and --file");
+      const text = v.text ?? readFileSync(v.file === "-" ? 0 : v.file, "utf8");
+      return print(await service.flow(board, text, actor(), { idPrefix: v.prefix }));
+    }
+    case "export": {
+      need(1, "<board> [--format svg|png] [--out <path>]");
+      const format = v.format ?? "svg";
+      if (format !== "svg" && format !== "png") throw new UsageError(`format must be svg or png, got "${format}"`);
+      if (format === "png" && !v.out) throw new UsageError("png is binary: pass --out <path>");
+      const data = format === "svg" ? await service.exportSvg(board) : await service.exportPng(board);
+      if (!v.out) return void process.stdout.write(`${data}
+`);
+      writeFileSync(v.out, data);
+      return print({ out: v.out, format, bytes: data.length });
+    }
+    case "repair":
+      need(1, "<board> [--drop <element>]...");
+      return print(await service.repair(board, actor(), v.drop ?? []));
+    case "mcp":
+      need(0, "");
+      return runMcp(service, actor());
+    default:
+      throw new UsageError(`unknown command "${command}"`);
+  }
+}
+run(process.argv.slice(2)).catch((error) => {
+  const code = error.code ?? "";
+  if (error instanceof UsageError || code.startsWith("ERR_PARSE_ARGS")) {
+    console.error(`${error.message}
+Run "${BRAND.command} --help" for usage.`);
+    process.exitCode = 2;
+  } else if (error instanceof CanvasError) {
+    console.error(`${error.code}: ${error.message}`);
+    process.exitCode = 1;
+  } else {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});

package/dist/index.d.ts

@@ -0,0 +1,285 @@
+import * as Y from 'yjs';
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Store } from 'agentic-identity';
+export { PRINCIPAL_KINDS, PrincipalKind, isMachineMade } from 'agentic-identity';
+export { FileStoreOptions, createFileStore, openLocalStore } from './store-file.js';
+
+declare const VERSION: string;
+
+declare const BRAND: {
+    readonly command: "agentic-canvas";
+    readonly description: "A shared whiteboard for diagrams, drawn by people and agents.";
+    readonly version: string;
+};
+
+declare const principalSchema: z.ZodObject<{
+    kind: z.ZodEnum<["human", "agent_of_human", "agent_of_agent", "agent", "user_token"]>;
+    id: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    kind: "human" | "agent_of_human" | "agent_of_agent" | "agent" | "user_token";
+}, {
+    id: string;
+    kind: "human" | "agent_of_human" | "agent_of_agent" | "agent" | "user_token";
+}>;
+type Principal = z.infer<typeof principalSchema>;
+
+type ErrorCode = "INVALID" | "DUPLICATE_ID" | "NOT_FOUND" | "BAD_REFERENCE" | "LIMIT" | "UNAVAILABLE" | "FORBIDDEN";
+declare class CanvasError extends Error {
+    readonly code: ErrorCode;
+    constructor(code: ErrorCode, message: string);
+}
+declare const SHAPE_TYPES: readonly ["rect", "ellipse", "diamond", "text", "sticky", "frame", "image"];
+type ShapeType = (typeof SHAPE_TYPES)[number];
+declare const MAX_ELEMENTS = 10000;
+declare const MAX_TEXT = 10000;
+type Endpoint = {
+    id: string;
+} | {
+    x: number;
+    y: number;
+};
+interface Stamp {
+    id: string;
+    z: number;
+    groupId?: string;
+    /** Who made the element. Never changes. */
+    author: Principal;
+    /** Who made the last edit. */
+    editedBy: Principal;
+}
+interface Shape extends Stamp {
+    type: ShapeType;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    text: string;
+    fill?: string;
+    stroke?: string;
+    src?: string;
+}
+interface Connector extends Stamp {
+    type: "connector";
+    from: Endpoint;
+    to: Endpoint;
+    text: string;
+    startArrow: boolean;
+    endArrow: boolean;
+    stroke?: string;
+}
+interface Group extends Stamp {
+    type: "group";
+}
+type CanvasElement = Shape | Connector | Group;
+/**
+ * A whiteboard on a Yjs doc. Headless: no UI code. Every write names its actor.
+ *
+ * A synced Yjs update is untrusted input. Every read checks each stored element against the same
+ * rules the write methods enforce, and returns only the checked fields. An entry that fails is
+ * hidden at once. `repair()` deletes it, and `Board.decode` runs `repair()`. This holds even
+ * when a caller writes to `doc` directly.
+ */
+declare class Board {
+    readonly doc: Y.Doc;
+    private readonly elements;
+    private readonly meta;
+    private maxElements;
+    constructor(doc?: Y.Doc, options?: {
+        maxElements?: number;
+    });
+    /** Load a saved board with no element checks. Only the owner repair path uses it. */
+    static open(update: Uint8Array): Board;
+    /**
+     * Load a saved board. Refuses a doc past the element cap. Then it deletes every entry that fails
+     * the element checks, and repairs what concurrent writers left broken.
+     */
+    static decode(update: Uint8Array): Board;
+    encode(): Uint8Array;
+    /** An independent copy. Edits to it leave this board alone. */
+    clone(): Board;
+    get title(): string;
+    get titleBy(): Principal | undefined;
+    setTitle(title: string, actor: Principal): void;
+    /** One element. An invalid entry, or a connector with a missing bound end, is hidden. */
+    get(elementId: string): CanvasElement | undefined;
+    /** All visible elements from back to front. */
+    list(): CanvasElement[];
+    /**
+     * Delete what peers can leave broken: entries that fail the element checks, connectors whose
+     * bound end is gone, and members that name a deleted group. Idempotent, so every peer may run it.
+     * `drop` names elements the owner removes too, with what they hold: a shape takes its connectors,
+     * a group takes its members. Refuses a result still past the cap, and then changes nothing.
+     * Returns the ids fixed.
+     */
+    repair(drop?: string[]): string[];
+    addShape(input: unknown, actor: Principal): Shape;
+    addConnector(input: unknown, actor: Principal): Connector;
+    update(elementId: string, patch: unknown, actor: Principal): CanvasElement;
+    /** Shift an element, or a whole group. Returns the ids that moved. Bound connector ends follow their shapes. */
+    move(elementId: string, dx: number, dy: number, actor: Principal): string[];
+    /** Delete an element. A shape takes its connectors and a group takes its members. Returns the ids removed. */
+    remove(elementId: string): string[];
+    group(ids: string[], actor: Principal, groupId?: string): Group;
+    /** Remove a group and hand its members to the parent group. */
+    ungroup(groupId: string, actor: Principal): void;
+    /** Put an element, or a group with its inner order kept, in front of or behind every other element. */
+    reorder(elementId: string, to: "front" | "back", actor: Principal): void;
+    /** One stored element that passes the checks and whose id matches its key, or undefined. */
+    private stored;
+    /** Every stored element that passes the checks, from back to front. Refuses a doc past the cap. */
+    private storedList;
+    /** Like storedList, with no cap check. Repair needs every entry, even on a board past the cap. */
+    private allStored;
+    /** A connector is detached when a bound end does not name a stored shape. */
+    private isDetached;
+    private require;
+    private checkEnd;
+    /** The z value just past the top or the bottom. Not clamped: the caller checks the range. */
+    private edgeZ;
+    /** The element and, for a group, everything below it. Cycle-safe. */
+    private subtree;
+    private subtreeIn;
+    private create;
+    /** Apply field changes and stamp the editor, all in one transaction. An undefined value clears the field. */
+    private write;
+}
+
+declare const MAX_FLOW_NODES = 500;
+declare const MAX_FLOW_EDGES = 2000;
+interface FlowNode {
+    id: string;
+    text: string;
+    shape: Extract<ShapeType, "rect" | "ellipse" | "diamond">;
+}
+interface FlowEdge {
+    from: string;
+    to: string;
+    text: string;
+}
+interface FlowGraph {
+    direction: "TB" | "LR";
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+}
+declare function parseFlow(source: string): FlowGraph;
+interface Placement {
+    id: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Layered layout. The top-left of the result is (0, 0). The layout breaks cycles and handles self-loops. */
+declare function layoutFlow(graph: FlowGraph): Placement[];
+interface DrawOptions {
+    /**
+     * Put in front of every id. Default: a new random prefix for each call, so two agents that draw at
+     * the same time never write the same id. A prefix you pass is used as given, and it makes ids
+     * repeatable. Up to 16 of A-Z, a-z, 0-9, _ and -.
+     */
+    idPrefix?: string;
+    /** Top-left of the drawing. Default: below the shapes already on the board. */
+    origin?: {
+        x: number;
+        y: number;
+    };
+}
+/** Draw a flow on the board. All or nothing: on any error the board stays as it was. */
+declare function drawFlow(board: Board, source: string, actor: Principal, options?: DrawOptions): {
+    nodes: string[];
+    edges: string[];
+};
+
+interface Labels {
+    /** The author is an agent or acts for one. */
+    machineMade: boolean;
+    /** The last edit came from an agent or one acting for one. */
+    lastEditMachineMade: boolean;
+}
+type NodeData = Shape & Labels;
+type EdgeData = Connector & Labels;
+interface BoardData {
+    title: string;
+    nodes: NodeData[];
+    edges: EdgeData[];
+    groups: {
+        id: string;
+        members: string[];
+    }[];
+    /** Every non-empty text, back to front. */
+    texts: string[];
+}
+/** The board as plain data for an agent. Reads only. Embedded image bytes are left out. */
+declare function readBoard(board: Board): BoardData;
+
+/** Draw the board, back to front, on a white background. */
+declare function toSvg(board: Board): string;
+
+/**
+ * Draw an SVG to PNG in a headless Chromium, through the optional
+ * `playwright-core` package. The page runs with JavaScript off and service
+ * workers blocked, and every network request is aborted, so a script planted in
+ * the SVG cannot run and nothing leaves the machine. When the package or the
+ * browser is missing, this throws.
+ */
+declare function svgToPng(svg: string): Promise<Uint8Array>;
+
+/** The operator set CANVAS_ACTOR wrong or not at all. */
+declare class ActorConfigError extends Error {
+}
+/**
+ * The actor for every write, from the operator's CANVAS_ACTOR as <kind>:<id>.
+ * A caller never picks its own actor or kind. Unset, empty, or bad is an error.
+ */
+declare function operatorActor(env?: Record<string, string | undefined>): Principal;
+
+/** One place for every board operation. The CLI, the MCP server, and the Worker call it. */
+declare class CanvasService {
+    private readonly store;
+    constructor(store: Store);
+    create(actor: Principal, options?: {
+        id?: string;
+        title?: string;
+    }): Promise<{
+        id: string;
+        title: string;
+    }>;
+    read(id: string): Promise<BoardData & {
+        id: string;
+    }>;
+    /** Run `change` on the board and save it, all inside one transaction. */
+    change<R>(id: string, change: (board: Board) => R): Promise<R>;
+    add(id: string, shape: unknown, actor: Principal): Promise<Shape>;
+    connect(id: string, connector: unknown, actor: Principal): Promise<Connector>;
+    move(id: string, elementId: string, dx: number, dy: number, actor: Principal): Promise<{
+        moved: string[];
+    }>;
+    remove(id: string, elementId: string): Promise<{
+        removed: string[];
+    }>;
+    flow(id: string, text: string, actor: Principal, options?: DrawOptions): Promise<{
+        nodes: string[];
+        edges: string[];
+    }>;
+    exportSvg(id: string): Promise<string>;
+    exportPng(id: string): Promise<Uint8Array>;
+    /** Owner only. Repair a board and delete the named elements. Only a human actor may call it. */
+    repair(id: string, actor: Principal, drop?: string[]): Promise<{
+        id: string;
+        fixed: string[];
+        elements: number;
+    }>;
+    private load;
+}
+
+/**
+ * The tools mirror the CLI. The actor is fixed here by the operator. No tool takes an actor,
+ * author, or kind, so a caller cannot choose who it writes as.
+ */
+declare function createMcpServer(service: CanvasService, actor: Principal): McpServer;
+/** Serve the tools on stdin and stdout. Stdout carries protocol frames only. */
+declare function runMcp(service: CanvasService, actor: Principal): Promise<void>;
+
+export { ActorConfigError, BRAND, Board, type BoardData, type CanvasElement, CanvasError, CanvasService, type Connector, type DrawOptions, type EdgeData, type Endpoint, type ErrorCode, type FlowEdge, type FlowGraph, type FlowNode, type Group, MAX_ELEMENTS, MAX_FLOW_EDGES, MAX_FLOW_NODES, MAX_TEXT, type NodeData, type Placement, type Principal, SHAPE_TYPES, type Shape, type ShapeType, VERSION, createMcpServer, drawFlow, layoutFlow, operatorActor, parseFlow, principalSchema, readBoard, runMcp, svgToPng, toSvg };

package/dist/index.js

@@ -0,0 +1,56 @@
+import {
+  ActorConfigError,
+  BRAND,
+  Board,
+  CanvasError,
+  CanvasService,
+  MAX_ELEMENTS,
+  MAX_FLOW_EDGES,
+  MAX_FLOW_NODES,
+  MAX_TEXT,
+  PRINCIPAL_KINDS,
+  SHAPE_TYPES,
+  VERSION,
+  createMcpServer,
+  drawFlow,
+  isMachineMade,
+  layoutFlow,
+  operatorActor,
+  parseFlow,
+  principalSchema,
+  readBoard,
+  runMcp,
+  svgToPng,
+  toSvg
+} from "./chunk-NSZ2AC5O.js";
+import {
+  createFileStore,
+  openLocalStore
+} from "./chunk-I3EJ5JB7.js";
+export {
+  ActorConfigError,
+  BRAND,
+  Board,
+  CanvasError,
+  CanvasService,
+  MAX_ELEMENTS,
+  MAX_FLOW_EDGES,
+  MAX_FLOW_NODES,
+  MAX_TEXT,
+  PRINCIPAL_KINDS,
+  SHAPE_TYPES,
+  VERSION,
+  createFileStore,
+  createMcpServer,
+  drawFlow,
+  isMachineMade,
+  layoutFlow,
+  openLocalStore,
+  operatorActor,
+  parseFlow,
+  principalSchema,
+  readBoard,
+  runMcp,
+  svgToPng,
+  toSvg
+};

package/dist/store-file.d.ts

@@ -0,0 +1,28 @@
+import { AdapterOptions, Store } from 'agentic-identity';
+
+/** A file store failure the caller can act on. `code` says why: LOCKED or DAMAGED. */
+declare class FileStoreError extends Error {
+    readonly code: "LOCKED" | "DAMAGED";
+    constructor(code: "LOCKED" | "DAMAGED", message: string);
+}
+
+interface FileStoreOptions extends AdapterOptions {
+    /** How long a write waits for the lock before it fails. Defaults to 10000. */
+    lockTimeoutMs?: number;
+    /** A lock older than this is stale, if its owner is alive. Defaults to 30000. */
+    staleAfterMs?: number;
+}
+/**
+ * A Store kept in one JSON file. Node only. It is an adapter of the shared Store port and passes `runStoreContract`. Many processes may share the file, for example the CLI
+ * and the MCP server. Each write takes a lock file, reads the file again, applies the change, and
+ * replaces the file by an atomic rename. A read sees the last renamed file, so it takes no lock.
+ * Each call reads the whole file and loads the docs it needs into the shared memory adapter, which runs the
+ * queries and the transaction rules. Cost grows with the file. Use it for local work, not for scale.
+ * The lock needs one machine: the process check and the clock do not work across hosts.
+ */
+declare function createFileStore(path: string, options?: FileStoreOptions): Store;
+/** The store the CLI and the MCP server share: one file in `dir`, which is made if it is missing. */
+declare function openLocalStore(dir: string): Store;
+declare const STORE_FILE = "canvas.json";
+
+export { FileStoreError, type FileStoreOptions, STORE_FILE, createFileStore, openLocalStore };

package/dist/store-file.js

@@ -0,0 +1,12 @@
+import {
+  FileStoreError,
+  STORE_FILE,
+  createFileStore,
+  openLocalStore
+} from "./chunk-I3EJ5JB7.js";
+export {
+  FileStoreError,
+  STORE_FILE,
+  createFileStore,
+  openLocalStore
+};

package/llms.txt

@@ -0,0 +1,13 @@
+# agentic-canvas
+
+A shared whiteboard for diagrams, drawn by people and agents.
+
+Keywords: whiteboard,canvas,diagrams,drawing,collaboration,agents,mcp,cli.
+
+- SDK: import { Board, drawFlow, readBoard, toSvg } from "agentic-canvas".
+- CLI: agentic-canvas new|read|add|connect|move|rm|flow|export.
+
+## Docs
+
+- README: https://github.com/pooriaarab/agentic-canvas
+- License: MIT

package/package.json

@@ -1,6 +1,79 @@
 {
   "name": "agentic-canvas",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "A shared whiteboard for diagrams, drawn by people and agents.",
+  "keywords": [
+    "whiteboard",
+    "canvas",
+    "diagrams",
+    "drawing",
+    "collaboration",
+    "agents",
+    "mcp",
+    "cli"
+  ],
+  "license": "MIT",
+  "author": "Pooria Arab",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pooriaarab/agentic-canvas.git"
+  },
+  "type": "module",
+  "private": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "llms.txt",
+    "SKILL.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "mcpName": "io.github.pooriaarab/agentic-canvas",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./file-store": {
+      "types": "./dist/store-file.d.ts",
+      "import": "./dist/store-file.js"
+    }
+  },
+  "bin": {
+    "agentic-canvas": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist",
+    "ci:local": "npm run build && npm run typecheck && npm test"
+  },
+  "dependencies": {
+    "@dagrejs/dagre": "^3.1.3",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "agentic-identity": "^0.2.0",
+    "yjs": "^13.6.0",
+    "zod": "^3.25.0"
+  },
+  "peerDependencies": {
+    "playwright-core": ">=1.40.0"
+  },
+  "peerDependenciesMeta": {
+    "playwright-core": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "playwright-core": "^1.64.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^3.0.0"
+  }
+}