@usejunior/docx-mcp 0.14.0 → 0.16.0

package/dist/tool_catalog.d.ts

@@ -1,6 +1,32 @@
 import { z } from 'zod';
+type ToolAnnotations = {
+    readOnlyHint: boolean;
+    destructiveHint: boolean;
+};
+/**
+ * Contract-surface classification for a tool's writes (#118 / #122).
+ *
+ * - `revisionable` — AI-attributed writes land as native OOXML tracked-change
+ *   markup (Table A of SUPPORT.md). Enforced by the write-time emitter (#120)
+ *   and validator (#121); exercised by the revisionable-surface property test.
+ * - `package-mutation` — writes mutate package-level parts with no native
+ *   revision wrapper (Table B). Recorded in the session non-revision change
+ *   manifest and surfaced in the save report rather than tracked.
+ * - `internal` — outside the AI-authoring contract: read-only utilities,
+ *   tracked-change consumers (accept_changes), and derived-output tools
+ *   (export, convert_to_odt). Matches SUPPORT.md's "Internal / non-contract".
+ *
+ * A tool may be primarily `revisionable` yet also touch package parts; those
+ * set `emitsNonRevisionChanges` and record manifest entries for the untracked
+ * portion (e.g. add_comment tracks the body reference but writes comment text
+ * to comments.xml).
+ *
+ * @see packages/docx-core/SUPPORT.md for the ratified per-tool inventory (#119).
+ */
+type ToolSurface = 'revisionable' | 'package-mutation' | 'internal';
 export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     readonly name: "read_file";
+    readonly surface: "internal";
     readonly description: "Read document content (DOCX, ODT, or Google Doc). Output is token-limited (~14k tokens) by default with pagination metadata (has_more, next_offset). Use offset/limit to paginate.";
     readonly input: z.ZodObject<{
         offset: z.ZodOptional<z.ZodNumber>;
@@ -19,6 +45,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
         }>>;
         show_formatting: z.ZodOptional<z.ZodBoolean>;
         include_fingerprint: z.ZodOptional<z.ZodBoolean>;
+        include_fingerprint_ordinal: z.ZodOptional<z.ZodBoolean>;
         include_footnotes: z.ZodOptional<z.ZodBoolean>;
         google_doc_id: z.ZodOptional<z.ZodString>;
         file_path: z.ZodOptional<z.ZodString>;
@@ -27,8 +54,25 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
         readonly readOnlyHint: true;
         readonly destructiveHint: false;
     };
+}, {
+    readonly name: "get_document_outline";
+    readonly surface: "internal";
+    readonly description: "Get a compact structural map of a document's headings (DOCX only). Returns one entry per heading paragraph with its text, outline level, source, and stable `_bk_*` paragraph_id — so an agent can read the cheap outline first, then scope a targeted read_file/replace_text to the right section instead of scanning the whole body. Style-based (Word HeadingN) headings only by default; set include_heuristic_headings=true to also include heuristic titles/run-in headers. Read-only.";
+    readonly input: z.ZodObject<{
+        format: z.ZodOptional<z.ZodEnum<{
+            json: "json";
+            markdown: "markdown";
+        }>>;
+        include_heuristic_headings: z.ZodOptional<z.ZodBoolean>;
+        file_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+    };
 }, {
     readonly name: "grep";
+    readonly surface: "internal";
     readonly description: "Search paragraphs with regex. Use file_path for session-based search, file_paths for stateless multi-file search, or google_doc_id for Google Docs. ODT supported via file_path (single-file) only.";
     readonly input: z.ZodObject<{
         file_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -50,7 +94,8 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "batch_edit";
-    readonly description: "Single-agent front door for applying multiple edit steps (replace_text, insert_paragraph) to a document in one call. Validates all steps first, rejects conflicts before applying anything, then executes valid steps sequentially. Accepts inline steps or a plan_file_path JSON array.";
+    readonly surface: "revisionable";
+    readonly description: "Single-agent front door for applying multiple edit steps (replace_text, insert_paragraph) to a document in one call. Validates all steps first, rejects conflicts before applying anything, then executes valid steps sequentially. Accepts inline steps or a plan_file_path JSON array. Surface: revisionable — every applied step emits native OOXML tracked changes.";
     readonly input: z.ZodObject<{
         steps: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>;
         plan_file_path: z.ZodOptional<z.ZodString>;
@@ -62,7 +107,8 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "replace_text";
-    readonly description: "Replace text in a paragraph by provider paragraph id, preserving formatting where supported. Supports DOCX, ODT, and Google Docs.";
+    readonly surface: "revisionable";
+    readonly description: "Replace text in a paragraph by provider paragraph id, preserving formatting where supported. Supports DOCX, ODT, and Google Docs. Surface: revisionable — DOCX edits emit native OOXML tracked changes (w:ins/w:del/w:rPrChange).";
     readonly input: z.ZodObject<{
         target_paragraph_id: z.ZodString;
         old_string: z.ZodString;
@@ -78,7 +124,8 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "insert_paragraph";
-    readonly description: "Insert a paragraph before/after an anchor paragraph by paragraph id. Supports DOCX, ODT, and Google Docs. (ODT paragraph ids are positional and shift after insertion — re-read before further edits.)";
+    readonly surface: "revisionable";
+    readonly description: "Insert a paragraph before/after an anchor paragraph by paragraph id. Supports DOCX, ODT, and Google Docs. (ODT paragraph ids are positional and shift after insertion — re-read before further edits.) Surface: revisionable — DOCX insertions emit native OOXML tracked changes.";
     readonly input: z.ZodObject<{
         positional_anchor_node_id: z.ZodString;
         new_string: z.ZodString;
@@ -97,7 +144,8 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "save";
-    readonly description: "Save document. For DOCX: saves clean and/or tracked changes output. For ODT: saves an .odt package. For Google Docs: checkpoint (default) returns revisionId, or snapshot exports as DOCX.";
+    readonly surface: "revisionable";
+    readonly description: "Save document. For DOCX: saves clean and/or tracked changes output. For ODT: saves an .odt package. For Google Docs: checkpoint (default) returns revisionId, or snapshot exports as DOCX. Surface: revisionable — the save report lists both the AI revisions applied and a non-revision change manifest of any package-level mutations (comment/footnote side parts, relationships) that have no tracked-change wrapper.";
     readonly input: z.ZodObject<{
         save_to_local_path: z.ZodString;
         clean_bookmarks: z.ZodOptional<z.ZodBoolean>;
@@ -123,6 +171,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "export";
+    readonly surface: "internal";
     readonly description: "Export a document to a portable rendering (Markdown, semantic HTML, or plain text). Writes an output file (default: source path with the format extension, e.g. .md, .html, or .txt) and returns its path, byte count, and the rendered content (under `content`). Intentionally lossy (no round-trip); HTML is the semantic tier, not pixel-faithful. DOCX only — Google Docs is not supported.";
     readonly input: z.ZodObject<{
         format: z.ZodOptional<z.ZodEnum<{
@@ -141,6 +190,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "convert_to_odt";
+    readonly surface: "internal";
     readonly description: "Convert a DOCX document to OpenDocument Text (.odt) using the native model-to-model converter (no LibreOffice involved). Writes the .odt (default: source path with the .odt extension), validates ODF packaging safety before writing, and returns the output path plus a `lossiness` summary itemizing every downgraded construct. Conversion is semantic and intentionally lossy: text, headings, bold/italic/underline, hyperlinks, lists, and tables are mapped; richer styling, tracked changes, comments, and headers/footers are not. DOCX in, ODT out — Google Docs and .odt inputs are not supported.";
     readonly input: z.ZodObject<{
         output_path: z.ZodOptional<z.ZodString>;
@@ -153,7 +203,8 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "format_layout";
-    readonly description: "Apply layout controls (paragraph spacing, table row height, cell padding). Google Docs supports paragraph spacing only.";
+    readonly surface: "revisionable";
+    readonly description: "Apply layout controls (paragraph spacing, table row height, cell padding). Google Docs supports paragraph spacing only. Surface: revisionable — DOCX geometry edits emit native property-change revisions (w:pPrChange/w:trPrChange/w:tcPrChange).";
     readonly input: z.ZodObject<{
         strict: z.ZodOptional<z.ZodBoolean>;
         paragraph_spacing: z.ZodOptional<z.ZodObject<{
@@ -162,8 +213,8 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
             after_twips: z.ZodOptional<z.ZodNumber>;
             line_twips: z.ZodOptional<z.ZodNumber>;
             line_rule: z.ZodOptional<z.ZodEnum<{
-                auto: "auto";
                 exact: "exact";
+                auto: "auto";
                 atLeast: "atLeast";
             }>>;
         }, z.core.$strip>>;
@@ -172,8 +223,8 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
             row_indexes: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
             value_twips: z.ZodOptional<z.ZodNumber>;
             rule: z.ZodOptional<z.ZodEnum<{
-                auto: "auto";
                 exact: "exact";
+                auto: "auto";
                 atLeast: "atLeast";
             }>>;
         }, z.core.$strip>>;
@@ -195,6 +246,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "accept_changes";
+    readonly surface: "internal";
     readonly description: "Accept all tracked changes in the document body, producing a clean document with no revision markup. Returns acceptance stats.";
     readonly input: z.ZodObject<{
         file_path: z.ZodString;
@@ -203,8 +255,37 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
         readonly readOnlyHint: false;
         readonly destructiveHint: true;
     };
+}, {
+    readonly name: "accept_ai_edits";
+    readonly surface: "internal";
+    readonly description: "Selectively accept tracked changes by revision id or author, leaving all other (e.g. third-party reviewer) revisions byte-untouched. Provide revision_ids (array of w:id values) to target specific revisions, or author to accept every revision by one actor. Sweeps document.xml and supported side-story parts (footnotes, endnotes, comments). An ambiguous overlap — a targeted revision structurally containing, or contained by, a non-targeted revision (nested ins/del/move) — hard-errors with code AMBIGUOUS_REVISION_OVERLAP and a structured `overlaps` list unless normalize_first is set (best-effort, no byte-identical promise).";
+    readonly input: z.ZodObject<{
+        revision_ids: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        author: z.ZodOptional<z.ZodString>;
+        normalize_first: z.ZodOptional<z.ZodBoolean>;
+        file_path: z.ZodString;
+    }, z.core.$strip>;
+    readonly annotations: {
+        readonly readOnlyHint: false;
+        readonly destructiveHint: true;
+    };
+}, {
+    readonly name: "reject_ai_edits";
+    readonly surface: "internal";
+    readonly description: "Selectively reject tracked changes by revision id or author (restoring their pre-edit state), leaving all other revisions byte-untouched. Symmetric to accept_ai_edits: provide revision_ids or author, sweeps document.xml and supported side-story parts, and hard-errors on an ambiguous overlap (code AMBIGUOUS_REVISION_OVERLAP with a structured `overlaps` list) unless normalize_first is set.";
+    readonly input: z.ZodObject<{
+        revision_ids: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        author: z.ZodOptional<z.ZodString>;
+        normalize_first: z.ZodOptional<z.ZodBoolean>;
+        file_path: z.ZodString;
+    }, z.core.$strip>;
+    readonly annotations: {
+        readonly readOnlyHint: false;
+        readonly destructiveHint: true;
+    };
 }, {
     readonly name: "has_tracked_changes";
+    readonly surface: "internal";
     readonly description: "Check whether the document body contains tracked-change markers (insertions, deletions, moves, and property-change records). Read-only.";
     readonly input: z.ZodObject<{
         file_path: z.ZodString;
@@ -215,6 +296,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "get_file_status";
+    readonly surface: "internal";
     readonly description: "Get file/session metadata including edit count, normalization stats, and cache info. Supports DOCX, ODT, and Google Docs.";
     readonly input: z.ZodObject<{
         google_doc_id: z.ZodOptional<z.ZodString>;
@@ -226,6 +308,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "close_file";
+    readonly surface: "internal";
     readonly description: "Close an open file session, or close all sessions with explicit confirmation. Supports DOCX, ODT, and Google Docs.";
     readonly input: z.ZodObject<{
         clear_all: z.ZodOptional<z.ZodBoolean>;
@@ -239,7 +322,9 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "add_comment";
-    readonly description: "Add a comment or threaded reply to a document. Provide target_paragraph_id + anchor_text for root comments, or parent_comment_id for replies. Supports DOCX and ODT (ODT backs comments with office:annotation; threaded replies are DOCX-only).";
+    readonly surface: "revisionable";
+    readonly emitsNonRevisionChanges: true;
+    readonly description: "Add a comment or threaded reply to a document. Provide target_paragraph_id + anchor_text for root comments, or parent_comment_id for replies. Supports DOCX and ODT (ODT backs comments with office:annotation; threaded replies are DOCX-only). Surface: revisionable + package-mutation — the body-story comment reference is tracked (w:ins), while comment text and author metadata are recorded in the save report non-revision change manifest.";
     readonly input: z.ZodObject<{
         target_paragraph_id: z.ZodOptional<z.ZodString>;
         anchor_text: z.ZodOptional<z.ZodString>;
@@ -255,6 +340,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "get_comments";
+    readonly surface: "internal";
     readonly description: "Get all comments from the document with IDs, authors, dates, text, and anchored paragraph IDs. Range-anchored DOCX comments also expose optional end_paragraph_id, start_run_index, start_char_offset, end_run_index, and end_char_offset fields describing the covered span. Includes threaded replies (DOCX). Supports DOCX and ODT. Read-only.";
     readonly input: z.ZodObject<{
         file_path: z.ZodString;
@@ -265,7 +351,9 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "delete_comment";
-    readonly description: "Delete a comment and all its threaded replies from the document. Cascade-deletes all descendants.";
+    readonly surface: "revisionable";
+    readonly emitsNonRevisionChanges: true;
+    readonly description: "Delete a comment and all its threaded replies from the document. Cascade-deletes all descendants. Surface: revisionable + package-mutation — the body-story comment reference removal is tracked (w:del), while comment/reply text cleanup is recorded in the save report non-revision change manifest.";
     readonly input: z.ZodObject<{
         comment_id: z.ZodNumber;
         file_path: z.ZodString;
@@ -276,6 +364,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "compare_documents";
+    readonly surface: "revisionable";
     readonly description: "Compare two documents and produce a tracked-changes output document. Provide original_file_path + revised_file_path for standalone comparison, or file_path to compare session edits against the original. DOCX and ODF (.odt) support both modes. DOCX stats count insertions/deletions as contiguous ranges, expose atom totals as insertedAtoms/deletedAtoms, and report formatChanges separately from modifiedParagraphs. ODF compares at inline granularity (a modified paragraph is marked up in place — only the changed spans are struck or inserted).";
     readonly input: z.ZodObject<{
         save_to_local_path: z.ZodString;
@@ -294,6 +383,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "get_footnotes";
+    readonly surface: "internal";
     readonly description: "Get all footnotes from the document with IDs, display numbers, text, and anchored paragraph IDs. Read-only.";
     readonly input: z.ZodObject<{
         file_path: z.ZodString;
@@ -304,7 +394,9 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "add_footnote";
-    readonly description: "Add a footnote anchored to a paragraph. Optionally position the reference after specific text using after_text. Note: [^N] markers in read_file output are display-only and not part of the editable text used by replace_text.";
+    readonly surface: "revisionable";
+    readonly emitsNonRevisionChanges: true;
+    readonly description: "Add a footnote anchored to a paragraph. Optionally position the reference after specific text using after_text. Note: [^N] markers in read_file output are display-only and not part of the editable text used by replace_text. Surface: revisionable + package-mutation — the footnote reference and note text are tracked (w:ins), while footnote-part creation and registration are recorded in the save report non-revision change manifest.";
     readonly input: z.ZodObject<{
         target_paragraph_id: z.ZodString;
         after_text: z.ZodOptional<z.ZodString>;
@@ -317,7 +409,8 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "update_footnote";
-    readonly description: "Update the text content of an existing footnote.";
+    readonly surface: "revisionable";
+    readonly description: "Update the text content of an existing footnote. Surface: revisionable — note-text changes emit native OOXML tracked changes (w:ins/w:del) inside the footnote body.";
     readonly input: z.ZodObject<{
         note_id: z.ZodNumber;
         new_text: z.ZodString;
@@ -329,7 +422,8 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "delete_footnote";
-    readonly description: "Delete a footnote and its reference from the document.";
+    readonly surface: "revisionable";
+    readonly description: "Delete a footnote and its reference from the document. Surface: revisionable — the reference and note text are removed as native OOXML tracked deletions (w:del).";
     readonly input: z.ZodObject<{
         note_id: z.ZodNumber;
         file_path: z.ZodString;
@@ -340,7 +434,8 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "clear_formatting";
-    readonly description: "Clear specific run-level formatting (bold, italic, underline, highlight, color, font) from paragraphs.";
+    readonly surface: "revisionable";
+    readonly description: "Clear specific run-level formatting (bold, italic, underline, highlight, color, font) from paragraphs. Surface: revisionable — clearing emits a native run-property-change revision (w:rPrChange).";
     readonly input: z.ZodObject<{
         paragraph_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
         clear_highlight: z.ZodOptional<z.ZodBoolean>;
@@ -357,6 +452,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "extract_revisions";
+    readonly surface: "internal";
     readonly description: "Extract tracked changes as structured JSON with before/after text per paragraph, revision details, and comments. Supports pagination via offset and limit. Read-only - does not modify the document.";
     readonly input: z.ZodObject<{
         offset: z.ZodOptional<z.ZodNumber>;
@@ -369,79 +465,23 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }];
 export declare const SAFE_DOCX_MCP_TOOLS: {
-    name: "read_file" | "grep" | "batch_edit" | "replace_text" | "insert_paragraph" | "save" | "export" | "convert_to_odt" | "format_layout" | "accept_changes" | "has_tracked_changes" | "get_file_status" | "close_file" | "add_comment" | "get_comments" | "delete_comment" | "compare_documents" | "get_footnotes" | "add_footnote" | "update_footnote" | "delete_footnote" | "clear_formatting" | "extract_revisions";
-    description: "Read document content (DOCX, ODT, or Google Doc). Output is token-limited (~14k tokens) by default with pagination metadata (has_more, next_offset). Use offset/limit to paginate." | "Search paragraphs with regex. Use file_path for session-based search, file_paths for stateless multi-file search, or google_doc_id for Google Docs. ODT supported via file_path (single-file) only." | "Single-agent front door for applying multiple edit steps (replace_text, insert_paragraph) to a document in one call. Validates all steps first, rejects conflicts before applying anything, then executes valid steps sequentially. Accepts inline steps or a plan_file_path JSON array." | "Replace text in a paragraph by provider paragraph id, preserving formatting where supported. Supports DOCX, ODT, and Google Docs." | "Insert a paragraph before/after an anchor paragraph by paragraph id. Supports DOCX, ODT, and Google Docs. (ODT paragraph ids are positional and shift after insertion — re-read before further edits.)" | "Save document. For DOCX: saves clean and/or tracked changes output. For ODT: saves an .odt package. For Google Docs: checkpoint (default) returns revisionId, or snapshot exports as DOCX." | "Export a document to a portable rendering (Markdown, semantic HTML, or plain text). Writes an output file (default: source path with the format extension, e.g. .md, .html, or .txt) and returns its path, byte count, and the rendered content (under `content`). Intentionally lossy (no round-trip); HTML is the semantic tier, not pixel-faithful. DOCX only — Google Docs is not supported." | "Convert a DOCX document to OpenDocument Text (.odt) using the native model-to-model converter (no LibreOffice involved). Writes the .odt (default: source path with the .odt extension), validates ODF packaging safety before writing, and returns the output path plus a `lossiness` summary itemizing every downgraded construct. Conversion is semantic and intentionally lossy: text, headings, bold/italic/underline, hyperlinks, lists, and tables are mapped; richer styling, tracked changes, comments, and headers/footers are not. DOCX in, ODT out — Google Docs and .odt inputs are not supported." | "Apply layout controls (paragraph spacing, table row height, cell padding). Google Docs supports paragraph spacing only." | "Accept all tracked changes in the document body, producing a clean document with no revision markup. Returns acceptance stats." | "Check whether the document body contains tracked-change markers (insertions, deletions, moves, and property-change records). Read-only." | "Get file/session metadata including edit count, normalization stats, and cache info. Supports DOCX, ODT, and Google Docs." | "Close an open file session, or close all sessions with explicit confirmation. Supports DOCX, ODT, and Google Docs." | "Add a comment or threaded reply to a document. Provide target_paragraph_id + anchor_text for root comments, or parent_comment_id for replies. Supports DOCX and ODT (ODT backs comments with office:annotation; threaded replies are DOCX-only)." | "Get all comments from the document with IDs, authors, dates, text, and anchored paragraph IDs. Range-anchored DOCX comments also expose optional end_paragraph_id, start_run_index, start_char_offset, end_run_index, and end_char_offset fields describing the covered span. Includes threaded replies (DOCX). Supports DOCX and ODT. Read-only." | "Delete a comment and all its threaded replies from the document. Cascade-deletes all descendants." | "Compare two documents and produce a tracked-changes output document. Provide original_file_path + revised_file_path for standalone comparison, or file_path to compare session edits against the original. DOCX and ODF (.odt) support both modes. DOCX stats count insertions/deletions as contiguous ranges, expose atom totals as insertedAtoms/deletedAtoms, and report formatChanges separately from modifiedParagraphs. ODF compares at inline granularity (a modified paragraph is marked up in place — only the changed spans are struck or inserted)." | "Get all footnotes from the document with IDs, display numbers, text, and anchored paragraph IDs. Read-only." | "Add a footnote anchored to a paragraph. Optionally position the reference after specific text using after_text. Note: [^N] markers in read_file output are display-only and not part of the editable text used by replace_text." | "Update the text content of an existing footnote." | "Delete a footnote and its reference from the document." | "Clear specific run-level formatting (bold, italic, underline, highlight, color, font) from paragraphs." | "Extract tracked changes as structured JSON with before/after text per paragraph, revision details, and comments. Supports pagination via offset and limit. Read-only - does not modify the document.";
+    name: string;
+    description: string;
     inputSchema: Record<string, unknown>;
-    annotations: {
-        readonly readOnlyHint: true;
-        readonly destructiveHint: false;
-    } | {
-        readonly readOnlyHint: true;
-        readonly destructiveHint: false;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: false;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: false;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: true;
-        readonly destructiveHint: false;
-    } | {
-        readonly readOnlyHint: true;
-        readonly destructiveHint: false;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: true;
-        readonly destructiveHint: false;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: true;
-        readonly destructiveHint: false;
-    } | {
-        readonly readOnlyHint: true;
-        readonly destructiveHint: false;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: false;
-        readonly destructiveHint: true;
-    } | {
-        readonly readOnlyHint: true;
-        readonly destructiveHint: false;
-    };
+    annotations: ToolAnnotations;
+    surface: ToolSurface;
+    emitsNonRevisionChanges: boolean;
 }[];
+/**
+ * Programmatic index of the contract surface each tool writes to (#122),
+ * mirroring the ratified inventory in `packages/docx-core/SUPPORT.md`.
+ * Consumed by the revisionable-surface property test and by the classification
+ * coverage test.
+ */
+export declare const TOOL_SURFACE_INDEX: Record<string, {
+    surface: ToolSurface;
+    emitsNonRevisionChanges: boolean;
+}>;
 export type SafeDocxToolName = (typeof SAFE_DOCX_TOOL_CATALOG)[number]['name'];
+export {};
 //# sourceMappingURL=tool_catalog.d.ts.map

package/dist/tool_catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool_catalog.d.ts","sourceRoot":"","sources":["../src/tool_catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6BxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2Wa,CAAC;AAUjD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAK7B,CAAC;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"tool_catalog.d.ts","sourceRoot":"","sources":["../src/tool_catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,KAAK,eAAe,GAAG;IACrB,YAAY,EAAE,OAAO,CAAC;IACtB,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,KAAK,WAAW,GAAG,cAAc,GAAG,kBAAkB,GAAG,UAAU,CAAC;AAkCpE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8ca,CAAC;AAUjD,eAAO,MAAM,mBAAmB;;;;;;;GAU7B,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,WAAW,CAAC;IAAC,uBAAuB,EAAE,OAAO,CAAA;CAAE,CAMvG,CAAC;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC"}