@pixerate/editor 0.22.0 → 0.23.0

package/README.md

@@ -169,6 +169,44 @@ await registry.callTool("insert_text", { text: "Hello" }); // { content: [...],
 
 `createEditorMcpToolProvider` exposes the static tools (`get_editor_state`, `edit_canvas`, `edit_prompt`, `view_editor`) through the registry, and `planToolCall` turns any tool call into planner steps (`step:tool_call` for registry tools).
 
+## Commands, shortcuts and the command palette
+
+`@pixerate/editor/commands` gives every action one id that menus, keyboard shortcuts, the command palette and agents all run, so they share enablement and parameter validation. It has no third-party imports.
+
+```ts
+import {
+  CommandRegistry,
+  createHistoryCommands,
+  createArrangeCommands,
+  createCommandToolProvider,
+  formatShortcut,
+} from "@pixerate/editor/commands";
+
+const commands = new CommandRegistry({ history }); // `history` makes `undoable` commands one undo step
+commands.register(createHistoryCommands(history)); // history.undo (Mod+Z), history.redo (Mod+Shift+Z, Mod+Y off macOS)
+commands.register(createArrangeCommands(arrange, { getSelectedIds })); // canvas.alignLeft (Alt+A), … scoped to "canvas"
+commands.register({
+  id: "doc.insertDate",
+  label: "Insert Date",
+  group: "Insert",
+  shortcut: "Mod+Shift+D",
+  params: { type: "object", properties: { format: { type: "string" } } },
+  enabled: (ctx) => (ctx.editable ? true : "The document is read-only."),
+  run: (ctx, { format }) => ctx.insertDate(format),
+});
+
+commands.execute("doc.insertDate", { fmt: "iso" });
+// { ok: false, code: "invalid_params", message: 'Unknown parameter "fmt" for command "doc.insertDate"; expected "format".' }
+commands.list({ scope: "canvas" }); // entries with shortcuts, enabled and disabledReason
+window.addEventListener("keydown", (e) => commands.handleKeyDown(e, { scopes: ["canvas"] }));
+formatShortcut("Mod+Shift+Z", "mac"); // "⇧⌘Z" ("Ctrl+Shift+Z" on Windows / Linux)
+```
+
+- **Results**: `execute` never throws. It returns `{ ok: true, result }` or `{ ok: false, code: "unknown_command" | "disabled" | "invalid_params" | "failed", message }`. `enabled(ctx, params)` returns `true` or a reason string, and receives the params the caller passed, so a command that acts on the selection can still run on ids passed in params. `executeAsync` awaits async commands.
+- **Shortcuts** (`registry.shortcuts`, a `ShortcutMap`): chords are platform-neutral (`Mod` is ⌘ on macOS and Ctrl elsewhere) and match `event.code`, so Option/Alt chords work on macOS. Letter keys follow Latin layouts such as AZERTY. Bindings can be scoped (`scope: "canvas"`), and scoped bindings win over global ones. Events from inputs and editors are ignored unless `allowInEditable` is set. `setOverride` / `getOverrides` store user remaps, and `findConflicts(platform)` reports chords that collide on a platform (e.g. `Mod+Y` and `Ctrl+Y` collide off macOS).
+- **Palette**: `rankCommands(query, entries, { recents })` does subsequence fuzzy ranking over label, group, keywords and id. Exact matches come first, and an empty query lists recent commands first. `createCommandPaletteController(registry)` holds the palette state that the React and Svelte `<CommandPalette>` components render.
+- **Agents**: `createCommandToolProvider(registry)` adds `list_commands`, `run_command` and `run_commands` to a `ToolRegistry`, with complete MCP annotations. `run_commands` runs steps in order but is **not atomic**: steps that succeeded before a failure stay applied. To get all-or-nothing behaviour, register one `undoable` command that runs the steps.
+
 ### Document structure and autocorrect
 
 Opt-in preset options add Word/Pages-style document structure:
@@ -195,13 +233,53 @@ Each module is also available as a subpath import:
 | `@pixerate/editor/grammar` | Tokenizer, resolver, sourcemaps. No TipTap or DOM dependencies, so it is safe for Node.js, workers and serverless functions. |
 | `@pixerate/editor/serializers` | Plain text, markdown and mention serializers |
 | `@pixerate/editor/extensions` | Headless TipTap extensions |
-| `@pixerate/editor/history` | `HistoryManager`: a command-pattern undo/redo stack |
+| `@pixerate/editor/history` | `HistoryManager`: a command-pattern undo/redo stack with gesture merge keys, undo marks, a byte budget and a History-panel listing; `DirtyTracker` / `bindDirtyToHistory` |
 | `@pixerate/editor/spreadsheet` | `SpreadsheetController`, formula parser/evaluator and dependency graph, formula function registry (`registerFormulaFunction`, `listFormulaFunctions`, `searchFormulaFunctions`, `getFormulaSignature`) and autocomplete helpers (`getFormulaHints`, `applyFormulaSuggestion`) |
 | `@pixerate/editor/image-editor` | `ImageEditorController` and Canvas 2D renderer: crop, adjustments, annotations, depth masks and AI hooks. Needs a DOM/canvas environment. |
 | `@pixerate/editor/canvas` | Node-graph layout (needs the optional `@dagrejs/dagre` peer), placement, trajectories, displacement, clipboard and streaming layout helpers |
 | `@pixerate/editor/agent` | MCP tool schemas, a planner for agent-driven canvas edits, and the dynamic `ToolRegistry` with editor/spreadsheet tool providers |
+| `@pixerate/editor/commands` | `CommandRegistry`, `ShortcutMap`, palette ranking, `createCommandToolProvider` and built-in history / arrange / spreadsheet commands (no third-party imports) |
+
+The root entry (`@pixerate/editor`) re-exports everything except canvas, agent, commands and image editor, including TipTap. Import from the narrowest subpath you need: `grammar`, `history`, `spreadsheet`, `commands` and `image-editor` have no third-party imports, so a spreadsheet-only app bundles no TipTap, markdown or dagre code. The package is marked `sideEffects: false`, so unused root exports are also tree-shaken.
+
+## History gestures, marks and dirty tracking
+
+```ts
+import { HistoryManager, bindDirtyToHistory } from "@pixerate/editor/history";
+
+const history = new HistoryManager({ maxDepth: 200, maxBytes: 32 << 20, sizeOf: (c) => c.byteSize ?? 0 });
+
+// A drag is one undo step, however long it lasts. Any other recorded command,
+// undo, redo or endGesture() ends it.
+history.executeMerged(setOpacity(0.4), { key: "opacity-slider" });
+history.executeMerged(setOpacity(0.5), { key: "opacity-slider" });
+
+// Hold a gesture: every merged execute until endGesture() joins one step.
+history.beginGesture("automation-pass");
+/* ... */
+history.endGesture();
+
+// Escape-cancel: take back everything since the drag started, with no redo left behind.
+const mark = history.mark();
+/* ... drag ... */
+history.revertTo(mark); // returns the number of steps reverted (0 if the mark is gone)
+
+// History panel
+history.getEntries(); // [{ id, label, index, current, undone }]
+history.goTo(2); // undo / redo until entry 2 is current; goTo(-1) undoes everything
+
+// Dirty vs saved: undoing back to the saved state is clean again.
+const dirty = bindDirtyToHistory({
+  history,
+  getValue: () => doc,
+  normalize: ({ selection, viewport, ...rest }) => rest, // selection/zoom never dirty
+});
+dirty.suppress(() => loadFromDisk()); // programmatic loads don't mark dirty (re-entrant)
+dirty.markClean(); // after saving
+dirty.dirty; // feed to useNavigationGuard / createNavigationGuard
+```
 
-The root entry (`@pixerate/editor`) re-exports everything except canvas, agent and image editor, including TipTap. Import from the narrowest subpath you need: `grammar`, `history`, `spreadsheet` and `image-editor` have no third-party imports, so a spreadsheet-only app bundles no TipTap, markdown or dagre code. The package is marked `sideEffects: false`, so unused root exports are also tree-shaken.
+Tag-only `executeMerged(cmd)` keeps its 300 ms time-window coalescing. React exposes the same API through `useHistory()` (`entries`, `goTo`, `mark`, `revertTo`, `beginGesture`, `endGesture`) and `useHistoryDirty()`; Svelte through `createHistory()` and `createHistoryDirty()`.
 
 ## License
 

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,88 @@
+# Third-Party Notices
+
+Portions of this repository are ported from third-party source code. Each ported file carries a
+header comment naming its source. The ported algorithms were re-expressed in TypeScript; test cases
+were re-expressed as vitest cases rather than copied.
+
+All sources below are from the ArtCraft "craft" apps, each licensed **MIT OR Apache-2.0**,
+© 2026 ArtCraft Team and the respective app's contributors. They are used here under the MIT licence
+reproduced at the end of this file. Paths are relative to each source repository.
+
+## figcraft
+
+© 2026 ArtCraft Team and the FigCraft contributors.
+
+- `crates/engine/src/distance.rs` (`between`, `inside`, `to_guide`, `label`) → `packages/core/src/canvas/measure.ts`
+- `crates/engine/src/measure_tests.rs` (test cases re-expressed) → `packages/core/tests/canvas-measure.test.ts`
+
+## filmcraft
+
+© 2026 ArtCraft Team and the FilmCraft contributors.
+
+- `crates/engine/src/lib.rs` (`Session::edit_merged`, `undo_mark`, `revert_to`) → `packages/core/src/history/HistoryManager.ts`
+- `crates/engine/src/commands.rs` (command specs, lookup by id, enablement with reasons) → `packages/core/src/commands/registry.ts`
+- `crates/engine/src/lib.rs` (`Session::execute`, `enabled_for`: re-checking enablement against targets named in params, catching command failures) → `packages/core/src/commands/registry.ts`
+- `crates/engine/src/shortcuts.rs` and `crates/engine/src/shortcuts_tests.rs` (platform-neutral chords, `Mod` resolution per platform, scoped bindings, conflict detection, per-platform conflict test) → `packages/core/src/commands/chords.ts`, `packages/core/src/commands/shortcuts.ts`, `packages/core/tests/commands.test.ts`
+- `crates/automation/src/server.rs` (`command_list` / `command_run` / `command_batch` tools, complete MCP annotations, unknown-argument errors naming the accepted keys) → `packages/core/src/commands/agentTools.ts`, `packages/core/src/commands/registry.ts`
+
+## gridcraft
+
+© 2026 ArtCraft Team and the GridCraft contributors.
+
+- `crates/core/src/parse.rs` (typed cell input parsing) → `packages/core/src/spreadsheet/formula/parse-input.ts`
+- `crates/core/src/date.rs` (1900 date-system serials, days in month, civil-day arithmetic) → `packages/core/src/spreadsheet/formula/parse-input.ts`
+- `crates/core/src/value.rs` (Excel comparison, 15-digit number comparison, sort order, number-to-text coercion) → `packages/core/src/spreadsheet/formula/values.ts`
+- Test cases from the files above, re-expressed → `packages/core/tests/spreadsheet-typed-input.test.ts`
+
+## lightcraft
+
+© 2026 ArtCraft Team and the LightCraft contributors.
+
+- `crates/color/src/cct.rs` (Kim et al. Planckian locus, temperature / tint ↔ xy, white-balance matrix) → `packages/core/src/image-editor/color.ts`
+- `crates/color/src/lib.rs` (Bradford adaptation, RGB ↔ XYZ from primaries) → `packages/core/src/image-editor/color.ts`
+- `crates/pipeline/src/tone.rs` (`ToneMap::display` S-curve anchored at 0, grey and 1) → `packages/core/src/image-editor/color.ts`
+- `crates/pipeline/src/local.rs` (relative white balance with neutral-luminance normalisation) → `packages/core/src/image-editor/color.ts`
+- `crates/develop/src/settings.rs` and `docs/process-versions.md` (process version semantics) → `packages/core/src/image-editor/color.ts`
+
+## photocraft
+
+© 2026 ArtCraft Team and the PhotoCraft contributors.
+
+- `crates/ops/src/lib.rs` (`History { max_states, max_bytes }`, `trim`, `unique_bytes`) → `packages/core/src/history/HistoryManager.ts`
+- `crates/ui-egui/src/palette.rs` (`fuzzy_score`, `exact_bonus`, `push_recent`) → `packages/core/src/commands/palette.ts`
+
+## soundcraft
+
+© 2026 ArtCraft Team and the SoundCraft contributors.
+
+- `crates/engine/src/lib.rs` (`Engine::execute_merged`, `hold_merge`, `end_merge`) → `packages/core/src/history/HistoryManager.ts`
+- `crates/engine/src/lib.rs` (`Engine::is_dirty`, `same_document`, `mark_clean`) → `packages/core/src/dirty.ts`
+
+## vectorcraft
+
+© 2026 ArtCraft Team and the VectorCraft contributors.
+
+- `crates/tools/src/guides.rs` (`snap_scale`) → `packages/core/src/canvas/resizeSnap.ts`
+- `crates/geom/src/snap.rs` (`snap_to_grid`) → `snapToGrid` in `packages/core/src/canvas/guides.ts`
+- `crates/pathops/src/fit.rs` (`fit_cubics`, `fit_single`, `fit_single_from`, `generate`, `newton`, `chord_params`, `is_straight`) → `packages/core/src/canvas/curveFit.ts`
+- `crates/pathops/src/edit.rs` (`simplify_with` corner splitting) → `packages/core/src/canvas/curveFit.ts`
+- Test cases from the files above and `crates/pathops/tests/ops.rs`, re-expressed → `packages/core/tests/canvas-resize-snap.test.ts`, `packages/core/tests/canvas-curve-fit.test.ts`
+
+---
+
+## MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/agent/index.cjs

@@ -1,5 +1,8 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
 
+var _chunkCPOKFNBGcjs = require('../chunk-CPOKFNBG.cjs');
+
+
 
 
 var _chunkAA4ZEVCCcjs = require('../chunk-AA4ZEVCC.cjs');
@@ -7,7 +10,7 @@ var _chunkAA4ZEVCCcjs = require('../chunk-AA4ZEVCC.cjs');
 
 
 
-var _chunkSAZRENEZcjs = require('../chunk-SAZRENEZ.cjs');
+var _chunkRIKBJLS2cjs = require('../chunk-RIKBJLS2.cjs');
 
 
 
@@ -276,6 +279,14 @@ function planToolCall(name, args, snapshot, options) {
 // src/agent/tools.ts
 var MCP_TOOL_GET_EDITOR_STATE = {
   name: "get_editor_state",
+  title: "Get editor state",
+  annotations: {
+    title: "Get editor state",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
   description: "Retrieves the current state of the document, variables, selection, and canvas graph (nodes and edges).",
   inputSchema: {
     type: "object",
@@ -293,6 +304,14 @@ var MCP_TOOL_GET_EDITOR_STATE = {
 };
 var MCP_TOOL_EDIT_CANVAS = {
   name: "edit_canvas",
+  title: "Edit the canvas",
+  annotations: {
+    title: "Edit the canvas",
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false
+  },
   description: "Applies high-level structural operations to the visual canvas (adding nodes, connecting edges, organizing layout, or moving elements).",
   inputSchema: {
     type: "object",
@@ -355,6 +374,14 @@ var MCP_TOOL_EDIT_CANVAS = {
 };
 var MCP_TOOL_EDIT_PROMPT = {
   name: "edit_prompt",
+  title: "Edit the prompt",
+  annotations: {
+    title: "Edit the prompt",
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false
+  },
   description: "Applies edits to the prompt template document, including inserting text, replacing ranges, and setting variables.",
   inputSchema: {
     type: "object",
@@ -393,6 +420,14 @@ var MCP_TOOL_EDIT_PROMPT = {
 };
 var MCP_TOOL_VIEW_EDITOR = {
   name: "view_editor",
+  title: "View the editor",
+  annotations: {
+    title: "View the editor",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
   description: "Captures a visual image snapshot (JPEG or PNG) of the editor canvas or viewport for multimodal evaluation. Active agent cursor indicators are automatically excluded from the snapshot.",
   inputSchema: {
     type: "object",
@@ -426,103 +461,6 @@ var EDITOR_MCP_TOOLS = [
   MCP_TOOL_VIEW_EDITOR
 ];
 
-// src/agent/schema.ts
-function typeOf(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
-  if (typeof value === "string" || typeof value === "boolean" || typeof value === "object") {
-    return typeof value;
-  }
-  return "undefined";
-}
-function matchesType(value, type) {
-  const actual = typeOf(value);
-  if (type === "number") return actual === "number" || actual === "integer";
-  return actual === type;
-}
-var isEqual = (a, b) => a === b || JSON.stringify(a) === JSON.stringify(b);
-function validateJsonSchema(value, schema, path = "") {
-  if (!schema || typeof schema !== "object") return [];
-  const errors = [];
-  const at = path || "/";
-  if (schema.type !== void 0) {
-    const types = Array.isArray(schema.type) ? schema.type : [schema.type];
-    if (!types.some((t) => matchesType(value, t))) {
-      errors.push({ path: at, message: `Expected ${types.join(" | ")}, got ${typeOf(value)}.` });
-      return errors;
-    }
-  }
-  if (schema.const !== void 0 && !isEqual(value, schema.const)) {
-    errors.push({ path: at, message: `Expected ${JSON.stringify(schema.const)}.` });
-  }
-  if (schema.enum && !schema.enum.some((option) => isEqual(value, option))) {
-    errors.push({
-      path: at,
-      message: `Expected one of ${schema.enum.map((o) => JSON.stringify(o)).join(", ")}, got ${JSON.stringify(value)}.`
-    });
-  }
-  if (typeof value === "string") {
-    if (schema.minLength !== void 0 && value.length < schema.minLength) {
-      errors.push({ path: at, message: `Must be at least ${schema.minLength} characters.` });
-    }
-    if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
-      errors.push({ path: at, message: `Must be at most ${schema.maxLength} characters.` });
-    }
-    if (schema.pattern !== void 0) {
-      let regex = null;
-      try {
-        regex = new RegExp(schema.pattern, "u");
-      } catch (e2) {
-      }
-      if (regex && !regex.test(value)) {
-        errors.push({ path: at, message: `Must match pattern ${schema.pattern}.` });
-      }
-    }
-  }
-  if (typeof value === "number") {
-    if (schema.minimum !== void 0 && value < schema.minimum) {
-      errors.push({ path: at, message: `Must be >= ${schema.minimum}.` });
-    }
-    if (schema.maximum !== void 0 && value > schema.maximum) {
-      errors.push({ path: at, message: `Must be <= ${schema.maximum}.` });
-    }
-  }
-  if (Array.isArray(value)) {
-    if (schema.minItems !== void 0 && value.length < schema.minItems) {
-      errors.push({ path: at, message: `Must have at least ${schema.minItems} items.` });
-    }
-    if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
-      errors.push({ path: at, message: `Must have at most ${schema.maxItems} items.` });
-    }
-    if (schema.items) {
-      value.forEach((item, index) => {
-        errors.push(...validateJsonSchema(item, schema.items, `${path}/${index}`));
-      });
-    }
-  }
-  if (typeOf(value) === "object") {
-    const obj = value;
-    for (const key of _nullishCoalesce(schema.required, () => ( []))) {
-      if (obj[key] === void 0) {
-        errors.push({ path: `${path}/${key}`, message: `Missing required property "${key}".` });
-      }
-    }
-    const properties = _nullishCoalesce(schema.properties, () => ( {}));
-    for (const [key, child] of Object.entries(obj)) {
-      if (child === void 0) continue;
-      if (key in properties) {
-        errors.push(...validateJsonSchema(child, properties[key], `${path}/${key}`));
-      } else if (schema.additionalProperties === false) {
-        errors.push({ path: `${path}/${key}`, message: `Unknown property "${key}".` });
-      } else if (typeof schema.additionalProperties === "object") {
-        errors.push(...validateJsonSchema(child, schema.additionalProperties, `${path}/${key}`));
-      }
-    }
-  }
-  return errors;
-}
-
 // src/agent/registry.ts
 var ToolRegistryError = class extends Error {
   
@@ -685,7 +623,7 @@ var ToolRegistry = (_class = class {
     }
     const input = _nullishCoalesce(args, () => ( {}));
     if (this.options.validateArguments) {
-      const details = validateJsonSchema(input, found.tool.inputSchema);
+      const details = _chunkCPOKFNBGcjs.validateJsonSchema.call(void 0, input, found.tool.inputSchema);
       if (details.length > 0) {
         return errorResult({
           code: "invalid_arguments",
@@ -742,7 +680,7 @@ var ToolRegistry = (_class = class {
   signature() {
     try {
       return JSON.stringify(this.listTools().tools);
-    } catch (e3) {
+    } catch (e2) {
       return String(Math.random());
     }
   }
@@ -773,6 +711,7 @@ function createRichTextToolProvider(target, options) {
   const editor = () => toEditor(target);
   const getText = {
     name: "get_text",
+    title: "Get document text",
     description: "Returns the document content (plain text by default, or HTML / markdown) and the current selection.",
     inputSchema: {
       type: "object",
@@ -785,7 +724,13 @@ function createRichTextToolProvider(target, options) {
       },
       additionalProperties: false
     },
-    annotations: { readOnlyHint: true },
+    annotations: {
+      title: "Get document text",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
     handler: ({ format = "text" }) => {
       const ed = editor();
       const content = format === "html" ? ed.getHTML() : format === "markdown" ? _chunkAA4ZEVCCcjs.getEditorMarkdown.call(void 0, ed) : _chunkAA4ZEVCCcjs.getEditorText.call(void 0, ed);
@@ -794,6 +739,7 @@ function createRichTextToolProvider(target, options) {
   };
   const insertText = {
     name: "insert_text",
+    title: "Insert text",
     description: "Inserts literal text (newlines start new paragraphs) at a document position, or at the cursor when `at` is omitted.",
     inputSchema: {
       type: "object",
@@ -804,6 +750,13 @@ function createRichTextToolProvider(target, options) {
       required: ["text"],
       additionalProperties: false
     },
+    annotations: {
+      title: "Insert text",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
     handler: ({ text, at }) => {
       const ed = editor();
       const size = ed.state.doc.content.size;
@@ -817,6 +770,7 @@ function createRichTextToolProvider(target, options) {
   };
   const replaceSelection = {
     name: "replace_selection",
+    title: "Replace selection",
     description: "Replaces the selected content with literal text (an empty string deletes the selection).",
     inputSchema: {
       type: "object",
@@ -824,7 +778,13 @@ function createRichTextToolProvider(target, options) {
       required: ["text"],
       additionalProperties: false
     },
-    annotations: { destructiveHint: true },
+    annotations: {
+      title: "Replace selection",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: false
+    },
     handler: ({ text }) => {
       const ed = editor();
       const { from, to } = ed.state.selection;
@@ -855,7 +815,7 @@ var CELL_REF_REGEX = /^\$?([A-Za-z]{1,3})\$?(\d{1,7})$/;
 function parseCell(ref) {
   const match = CELL_REF_REGEX.exec(ref.trim());
   if (!match) throw new Error(`Invalid cell reference "${ref}". Use A1 notation, e.g. "B3".`);
-  return { col: _chunkSAZRENEZcjs.colNameToIndex.call(void 0, match[1].toUpperCase()), row: parseInt(match[2], 10) - 1 };
+  return { col: _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, match[1].toUpperCase()), row: parseInt(match[2], 10) - 1 };
 }
 function createSpreadsheetToolProvider(controller, options) {
   const lookup = (row, col) => {
@@ -865,6 +825,7 @@ function createSpreadsheetToolProvider(controller, options) {
   };
   const getRange = {
     name: "get_range",
+    title: "Read cells",
     description: 'Reads a cell range in A1 notation (e.g. "A1:C5" or "B2") and returns computed values, raw input and errors.',
     inputSchema: {
       type: "object",
@@ -874,7 +835,13 @@ function createSpreadsheetToolProvider(controller, options) {
       required: ["range"],
       additionalProperties: false
     },
-    annotations: { readOnlyHint: true },
+    annotations: {
+      title: "Read cells",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
     handler: ({ range }) => {
       const [startRef, endRef = startRef] = String(range).split(":");
       const start = parseCell(startRef);
@@ -896,14 +863,14 @@ function createSpreadsheetToolProvider(controller, options) {
           const cell = controller.getCell(found.rowDef.id, found.colDef.id);
           valueRow.push(_nullishCoalesce(cell.error, () => ( cell.value)));
           rawRow.push(cell.raw);
-          const error = _nullishCoalesce(cell.error, () => ( (_chunkSAZRENEZcjs.isFormulaError.call(void 0, cell.value) ? cell.value : void 0)));
-          if (error) errors.push({ cell: `${_chunkSAZRENEZcjs.indexToColName.call(void 0, c)}${r + 1}`, error });
+          const error = _nullishCoalesce(cell.error, () => ( (_chunkRIKBJLS2cjs.isFormulaError.call(void 0, cell.value) ? cell.value : void 0)));
+          if (error) errors.push({ cell: `${_chunkRIKBJLS2cjs.indexToColName.call(void 0, c)}${r + 1}`, error });
         }
         values.push(valueRow);
         raw.push(rawRow);
       }
       return {
-        range: values.length && values[0].length ? `${_chunkSAZRENEZcjs.indexToColName.call(void 0, c0)}${r0 + 1}:${_chunkSAZRENEZcjs.indexToColName.call(void 0, c1)}${r1 + 1}` : null,
+        range: values.length && values[0].length ? `${_chunkRIKBJLS2cjs.indexToColName.call(void 0, c0)}${r0 + 1}:${_chunkRIKBJLS2cjs.indexToColName.call(void 0, c1)}${r1 + 1}` : null,
         values,
         raw,
         errors,
@@ -913,6 +880,7 @@ function createSpreadsheetToolProvider(controller, options) {
   };
   const setCell = {
     name: "set_cell",
+    title: "Set a cell",
     description: 'Sets the raw input of one cell (A1 notation). Values starting with "=" are formulas.',
     inputSchema: {
       type: "object",
@@ -923,6 +891,13 @@ function createSpreadsheetToolProvider(controller, options) {
       required: ["cell", "value"],
       additionalProperties: false
     },
+    annotations: {
+      title: "Set a cell",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
     handler: ({ cell, value }) => {
       const { row, col } = parseCell(cell);
       const found = lookup(row, col);
@@ -993,5 +968,5 @@ function createEditorMcpToolProvider(options) {
 
 
 
-exports.EDITOR_MCP_TOOLS = EDITOR_MCP_TOOLS; exports.EXPORT_EXCLUDED_SELECTORS = EXPORT_EXCLUDED_SELECTORS; exports.MCP_TOOL_EDIT_CANVAS = MCP_TOOL_EDIT_CANVAS; exports.MCP_TOOL_EDIT_PROMPT = MCP_TOOL_EDIT_PROMPT; exports.MCP_TOOL_GET_EDITOR_STATE = MCP_TOOL_GET_EDITOR_STATE; exports.MCP_TOOL_VIEW_EDITOR = MCP_TOOL_VIEW_EDITOR; exports.TOOL_NAMESPACE_SEPARATOR = TOOL_NAMESPACE_SEPARATOR; exports.ToolRegistry = ToolRegistry; exports.ToolRegistryError = ToolRegistryError; exports.createEditorMcpToolProvider = createEditorMcpToolProvider; exports.createRichTextToolProvider = createRichTextToolProvider; exports.createSpreadsheetToolProvider = createSpreadsheetToolProvider; exports.createToolRegistry = createToolRegistry; exports.normalizeSide = normalizeSide; exports.planAgentCommand = planAgentCommand; exports.planToolCall = planToolCall; exports.toToolResult = toToolResult; exports.toolCallToAgentCommand = toolCallToAgentCommand; exports.validateJsonSchema = validateJsonSchema;
+exports.EDITOR_MCP_TOOLS = EDITOR_MCP_TOOLS; exports.EXPORT_EXCLUDED_SELECTORS = EXPORT_EXCLUDED_SELECTORS; exports.MCP_TOOL_EDIT_CANVAS = MCP_TOOL_EDIT_CANVAS; exports.MCP_TOOL_EDIT_PROMPT = MCP_TOOL_EDIT_PROMPT; exports.MCP_TOOL_GET_EDITOR_STATE = MCP_TOOL_GET_EDITOR_STATE; exports.MCP_TOOL_VIEW_EDITOR = MCP_TOOL_VIEW_EDITOR; exports.TOOL_NAMESPACE_SEPARATOR = TOOL_NAMESPACE_SEPARATOR; exports.ToolRegistry = ToolRegistry; exports.ToolRegistryError = ToolRegistryError; exports.createEditorMcpToolProvider = createEditorMcpToolProvider; exports.createRichTextToolProvider = createRichTextToolProvider; exports.createSpreadsheetToolProvider = createSpreadsheetToolProvider; exports.createToolRegistry = createToolRegistry; exports.normalizeSide = normalizeSide; exports.planAgentCommand = planAgentCommand; exports.planToolCall = planToolCall; exports.toToolResult = toToolResult; exports.toolCallToAgentCommand = toolCallToAgentCommand; exports.validateJsonSchema = _chunkCPOKFNBGcjs.validateJsonSchema;
 //# sourceMappingURL=index.cjs.map