@superdoc/mcp 1.2.0-next.1 → 1.2.0-next.10

package/dist/index.js

@@ -31314,7 +31314,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.15.0-next.1";
+var SDK_VERSION = "2.15.0-next.10";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { chmodSync, existsSync } from "node:fs";
@@ -31891,7 +31891,7 @@ var init_embedded_tools_generated = __esm(() => {
   "tools": [
     {
       "toolName": "superdoc_get_content",
-      "description": "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. Action \\"blocks\\" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. When you need to evaluate or rewrite existing paragraphs or clauses, prefer action \\"blocks\\" with includeText:true so you can identify the correct block and then target it by nodeId. Actions \\"text\\", \\"markdown\\", and \\"html\\" return compact strings. Actions \\"markdown_projection\\" and \\"html_projection\\" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. Action \\"info\\" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. The \\"blocks\\" action supports pagination via \\"offset\\" and \\"limit\\", filtering via \\"nodeTypes\\", and numbering projection via \\"reviewMode\\". Other actions ignore pagination and filtering parameters. This tool never modifies the document. Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"blocks\\"}\\n  2. {\\"action\\":\\"blocks\\",\\"includeText\\":true,\\"offset\\":0,\\"limit\\":20,\\"reviewMode\\":\\"final\\"}\\n  3. {\\"action\\":\\"blocks\\",\\"offset\\":0,\\"limit\\":20,\\"nodeTypes\\":[\\"heading\\",\\"paragraph\\"]}\\n  4. {\\"action\\":\\"text\\"}\\n  5. {\\"action\\":\\"info\\"}\\n  6. {\\"action\\":\\"html_projection\\",\\"reviewMode\\":\\"redline\\",\\"includeSourceMap\\":true}\\n  7. {\\"action\\":\\"markdown_projection\\",\\"reviewMode\\":\\"original\\",\\"scope\\":{\\"kind\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"paragraph-id\\"},\\"includeSourceMap\\":true}",
+      "description": "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. Action \\"blocks\\" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Paragraph-class blocks include tabCount, the number of U+0009 tabs in the complete text even if the 80-character preview trims or truncates them. If tabCount is positive, read includeText:true before editing; do not treat a preview space as proof that there is no tab. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. When you need to evaluate or rewrite existing paragraphs or clauses, prefer action \\"blocks\\" with includeText:true so you can identify the correct block and then target it by nodeId. Actions \\"text\\", \\"markdown\\", and \\"html\\" return compact strings. Actions \\"markdown_projection\\" and \\"html_projection\\" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. Action \\"info\\" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. The \\"blocks\\" action supports pagination via \\"offset\\" and \\"limit\\", filtering via \\"nodeTypes\\", and numbering projection via \\"reviewMode\\". Other actions ignore pagination and filtering parameters. This tool never modifies the document. Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"blocks\\"}\\n  2. {\\"action\\":\\"blocks\\",\\"includeText\\":true,\\"offset\\":0,\\"limit\\":20,\\"reviewMode\\":\\"final\\"}\\n  3. {\\"action\\":\\"blocks\\",\\"offset\\":0,\\"limit\\":20,\\"nodeTypes\\":[\\"heading\\",\\"paragraph\\"]}\\n  4. {\\"action\\":\\"text\\"}\\n  5. {\\"action\\":\\"info\\"}\\n  6. {\\"action\\":\\"html_projection\\",\\"reviewMode\\":\\"redline\\",\\"includeSourceMap\\":true}\\n  7. {\\"action\\":\\"markdown_projection\\",\\"reviewMode\\":\\"original\\",\\"scope\\":{\\"kind\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"paragraph-id\\"},\\"includeSourceMap\\":true}",
       "inputSchema": {
         "type": "object",
         "properties": {
@@ -38169,7 +38169,7 @@ var init_embedded_tools_generated = __esm(() => {
     },
     {
       "toolName": "superdoc_mutations",
-      "description": "All steps succeed or all fail; no partial application. Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. Each step has an id, an op, a \\"where\\" clause for targeting ({by:\\"select\\", select:{...}, require:\\"first\\"|\\"exactlyOne\\"|\\"all\\"} or {by:\\"ref\\", ref:\\"...\\"} or {by:\\"block\\", nodeType:\\"paragraph\\", nodeId:\\"...\\"}), and \\"args\\" with operation-specific parameters. Use {by:\\"block\\", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action \\"blocks\\" without relying on text matching. For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:\\"blocks\\" and includeText:true, then rewrite the matching block by nodeId. Use {by:\\"select\\"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. For create steps, \\"where\\" targets an existing anchor block and args.position (\\"before\\" or \\"after\\") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. For format.apply with require \\"all\\", use a node selector to format every heading or paragraph at once: {by:\\"select\\", select:{type:\\"node\\", nodeType:\\"heading\\"}, require:\\"all\\"}. Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. Action \\"preview\\" dry-runs the plan. Action \\"apply\\" executes it. If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"apply\\",\\"atomic\\":true,\\"changeMode\\":\\"direct\\",\\"steps\\":[{\\"id\\":\\"s1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"old term\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"new term\\"}}},{\\"id\\":\\"s2\\",\\"op\\":\\"text.delete\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\" (deprecated)\\"},\\"require\\":\\"all\\"},\\"args\\":{}}]}\\n  2. {\\"action\\":\\"apply\\",\\"steps\\":[{\\"id\\":\\"r1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"<nodeId>\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"Updated clause text.\\"}}},{\\"id\\":\\"f1\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"node\\",\\"nodeType\\":\\"heading\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"color\\":\\"#FF0000\\"}}},{\\"id\\":\\"f2\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"Confidential Information\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"bold\\":true}}}]}",
+      "description": "All steps succeed or all fail; no partial application. Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. Each step has an id, an op, a \\"where\\" clause for targeting ({by:\\"select\\", select:{...}, require:\\"first\\"|\\"exactlyOne\\"|\\"all\\"} or {by:\\"ref\\", ref:\\"...\\"} or {by:\\"block\\", nodeType:\\"paragraph\\", nodeId:\\"...\\"}), and \\"args\\" with operation-specific parameters. Use {by:\\"block\\", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action \\"blocks\\" without relying on text matching. For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:\\"blocks\\" and includeText:true, then rewrite the matching block by nodeId. For a placeholder or name within a tab-separated paragraph, use a text.rewrite where.by:\\"select\\" targeting only the exact placeholder; a whole-block plain-text rewrite omitting tabs deletes those controls. Use {by:\\"select\\"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. For create steps, \\"where\\" targets an existing anchor block and args.position (\\"before\\" or \\"after\\") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. For format.apply with require \\"all\\", use a node selector to format every heading or paragraph at once: {by:\\"select\\", select:{type:\\"node\\", nodeType:\\"heading\\"}, require:\\"all\\"}. Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. Action \\"preview\\" dry-runs the plan. Action \\"apply\\" executes it. If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"apply\\",\\"atomic\\":true,\\"changeMode\\":\\"direct\\",\\"steps\\":[{\\"id\\":\\"s1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"old term\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"new term\\"}}},{\\"id\\":\\"s2\\",\\"op\\":\\"text.delete\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\" (deprecated)\\"},\\"require\\":\\"all\\"},\\"args\\":{}}]}\\n  2. {\\"action\\":\\"apply\\",\\"steps\\":[{\\"id\\":\\"r1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"<nodeId>\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"Updated clause text.\\"}}},{\\"id\\":\\"f1\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"node\\",\\"nodeType\\":\\"heading\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"color\\":\\"#FF0000\\"}}},{\\"id\\":\\"f2\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"Confidential Information\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"bold\\":true}}}]}",
       "inputSchema": {
         "type": "object",
         "properties": {
@@ -42255,7 +42255,7 @@ var init_embedded_tools_generated = __esm(() => {
       "type": "function",
       "function": {
         "name": "superdoc_get_content",
-        "description": "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. Action \\"blocks\\" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. When you need to evaluate or rewrite existing paragraphs or clauses, prefer action \\"blocks\\" with includeText:true so you can identify the correct block and then target it by nodeId. Actions \\"text\\", \\"markdown\\", and \\"html\\" return compact strings. Actions \\"markdown_projection\\" and \\"html_projection\\" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. Action \\"info\\" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. The \\"blocks\\" action supports pagination via \\"offset\\" and \\"limit\\", filtering via \\"nodeTypes\\", and numbering projection via \\"reviewMode\\". Other actions ignore pagination and filtering parameters. This tool never modifies the document. Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"blocks\\"}\\n  2. {\\"action\\":\\"blocks\\",\\"includeText\\":true,\\"offset\\":0,\\"limit\\":20,\\"reviewMode\\":\\"final\\"}\\n  3. {\\"action\\":\\"blocks\\",\\"offset\\":0,\\"limit\\":20,\\"nodeTypes\\":[\\"heading\\",\\"paragraph\\"]}\\n  4. {\\"action\\":\\"text\\"}\\n  5. {\\"action\\":\\"info\\"}\\n  6. {\\"action\\":\\"html_projection\\",\\"reviewMode\\":\\"redline\\",\\"includeSourceMap\\":true}\\n  7. {\\"action\\":\\"markdown_projection\\",\\"reviewMode\\":\\"original\\",\\"scope\\":{\\"kind\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"paragraph-id\\"},\\"includeSourceMap\\":true}",
+        "description": "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. Action \\"blocks\\" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Paragraph-class blocks include tabCount, the number of U+0009 tabs in the complete text even if the 80-character preview trims or truncates them. If tabCount is positive, read includeText:true before editing; do not treat a preview space as proof that there is no tab. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. When you need to evaluate or rewrite existing paragraphs or clauses, prefer action \\"blocks\\" with includeText:true so you can identify the correct block and then target it by nodeId. Actions \\"text\\", \\"markdown\\", and \\"html\\" return compact strings. Actions \\"markdown_projection\\" and \\"html_projection\\" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. Action \\"info\\" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. The \\"blocks\\" action supports pagination via \\"offset\\" and \\"limit\\", filtering via \\"nodeTypes\\", and numbering projection via \\"reviewMode\\". Other actions ignore pagination and filtering parameters. This tool never modifies the document. Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"blocks\\"}\\n  2. {\\"action\\":\\"blocks\\",\\"includeText\\":true,\\"offset\\":0,\\"limit\\":20,\\"reviewMode\\":\\"final\\"}\\n  3. {\\"action\\":\\"blocks\\",\\"offset\\":0,\\"limit\\":20,\\"nodeTypes\\":[\\"heading\\",\\"paragraph\\"]}\\n  4. {\\"action\\":\\"text\\"}\\n  5. {\\"action\\":\\"info\\"}\\n  6. {\\"action\\":\\"html_projection\\",\\"reviewMode\\":\\"redline\\",\\"includeSourceMap\\":true}\\n  7. {\\"action\\":\\"markdown_projection\\",\\"reviewMode\\":\\"original\\",\\"scope\\":{\\"kind\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"paragraph-id\\"},\\"includeSourceMap\\":true}",
         "parameters": {
           "type": "object",
           "properties": {
@@ -48137,7 +48137,7 @@ var init_embedded_tools_generated = __esm(() => {
       "type": "function",
       "function": {
         "name": "superdoc_mutations",
-        "description": "All steps succeed or all fail; no partial application. Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. Each step has an id, an op, a \\"where\\" clause for targeting ({by:\\"select\\", select:{...}, require:\\"first\\"|\\"exactlyOne\\"|\\"all\\"} or {by:\\"ref\\", ref:\\"...\\"} or {by:\\"block\\", nodeType:\\"paragraph\\", nodeId:\\"...\\"}), and \\"args\\" with operation-specific parameters. Use {by:\\"block\\", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action \\"blocks\\" without relying on text matching. For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:\\"blocks\\" and includeText:true, then rewrite the matching block by nodeId. Use {by:\\"select\\"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. For create steps, \\"where\\" targets an existing anchor block and args.position (\\"before\\" or \\"after\\") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. For format.apply with require \\"all\\", use a node selector to format every heading or paragraph at once: {by:\\"select\\", select:{type:\\"node\\", nodeType:\\"heading\\"}, require:\\"all\\"}. Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. Action \\"preview\\" dry-runs the plan. Action \\"apply\\" executes it. If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"apply\\",\\"atomic\\":true,\\"changeMode\\":\\"direct\\",\\"steps\\":[{\\"id\\":\\"s1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"old term\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"new term\\"}}},{\\"id\\":\\"s2\\",\\"op\\":\\"text.delete\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\" (deprecated)\\"},\\"require\\":\\"all\\"},\\"args\\":{}}]}\\n  2. {\\"action\\":\\"apply\\",\\"steps\\":[{\\"id\\":\\"r1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"<nodeId>\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"Updated clause text.\\"}}},{\\"id\\":\\"f1\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"node\\",\\"nodeType\\":\\"heading\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"color\\":\\"#FF0000\\"}}},{\\"id\\":\\"f2\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"Confidential Information\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"bold\\":true}}}]}",
+        "description": "All steps succeed or all fail; no partial application. Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. Each step has an id, an op, a \\"where\\" clause for targeting ({by:\\"select\\", select:{...}, require:\\"first\\"|\\"exactlyOne\\"|\\"all\\"} or {by:\\"ref\\", ref:\\"...\\"} or {by:\\"block\\", nodeType:\\"paragraph\\", nodeId:\\"...\\"}), and \\"args\\" with operation-specific parameters. Use {by:\\"block\\", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action \\"blocks\\" without relying on text matching. For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:\\"blocks\\" and includeText:true, then rewrite the matching block by nodeId. For a placeholder or name within a tab-separated paragraph, use a text.rewrite where.by:\\"select\\" targeting only the exact placeholder; a whole-block plain-text rewrite omitting tabs deletes those controls. Use {by:\\"select\\"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. For create steps, \\"where\\" targets an existing anchor block and args.position (\\"before\\" or \\"after\\") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. For format.apply with require \\"all\\", use a node selector to format every heading or paragraph at once: {by:\\"select\\", select:{type:\\"node\\", nodeType:\\"heading\\"}, require:\\"all\\"}. Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. Action \\"preview\\" dry-runs the plan. Action \\"apply\\" executes it. If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"apply\\",\\"atomic\\":true,\\"changeMode\\":\\"direct\\",\\"steps\\":[{\\"id\\":\\"s1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"old term\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"new term\\"}}},{\\"id\\":\\"s2\\",\\"op\\":\\"text.delete\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\" (deprecated)\\"},\\"require\\":\\"all\\"},\\"args\\":{}}]}\\n  2. {\\"action\\":\\"apply\\",\\"steps\\":[{\\"id\\":\\"r1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"<nodeId>\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"Updated clause text.\\"}}},{\\"id\\":\\"f1\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"node\\",\\"nodeType\\":\\"heading\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"color\\":\\"#FF0000\\"}}},{\\"id\\":\\"f2\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"Confidential Information\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"bold\\":true}}}]}",
         "parameters": {
           "type": "object",
           "properties": {
@@ -51875,7 +51875,7 @@ var init_embedded_tools_generated = __esm(() => {
   "tools": [
     {
       "name": "superdoc_get_content",
-      "description": "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. Action \\"blocks\\" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. When you need to evaluate or rewrite existing paragraphs or clauses, prefer action \\"blocks\\" with includeText:true so you can identify the correct block and then target it by nodeId. Actions \\"text\\", \\"markdown\\", and \\"html\\" return compact strings. Actions \\"markdown_projection\\" and \\"html_projection\\" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. Action \\"info\\" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. The \\"blocks\\" action supports pagination via \\"offset\\" and \\"limit\\", filtering via \\"nodeTypes\\", and numbering projection via \\"reviewMode\\". Other actions ignore pagination and filtering parameters. This tool never modifies the document. Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"blocks\\"}\\n  2. {\\"action\\":\\"blocks\\",\\"includeText\\":true,\\"offset\\":0,\\"limit\\":20,\\"reviewMode\\":\\"final\\"}\\n  3. {\\"action\\":\\"blocks\\",\\"offset\\":0,\\"limit\\":20,\\"nodeTypes\\":[\\"heading\\",\\"paragraph\\"]}\\n  4. {\\"action\\":\\"text\\"}\\n  5. {\\"action\\":\\"info\\"}\\n  6. {\\"action\\":\\"html_projection\\",\\"reviewMode\\":\\"redline\\",\\"includeSourceMap\\":true}\\n  7. {\\"action\\":\\"markdown_projection\\",\\"reviewMode\\":\\"original\\",\\"scope\\":{\\"kind\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"paragraph-id\\"},\\"includeSourceMap\\":true}",
+      "description": "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. Action \\"blocks\\" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Paragraph-class blocks include tabCount, the number of U+0009 tabs in the complete text even if the 80-character preview trims or truncates them. If tabCount is positive, read includeText:true before editing; do not treat a preview space as proof that there is no tab. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. When you need to evaluate or rewrite existing paragraphs or clauses, prefer action \\"blocks\\" with includeText:true so you can identify the correct block and then target it by nodeId. Actions \\"text\\", \\"markdown\\", and \\"html\\" return compact strings. Actions \\"markdown_projection\\" and \\"html_projection\\" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. Action \\"info\\" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. The \\"blocks\\" action supports pagination via \\"offset\\" and \\"limit\\", filtering via \\"nodeTypes\\", and numbering projection via \\"reviewMode\\". Other actions ignore pagination and filtering parameters. This tool never modifies the document. Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"blocks\\"}\\n  2. {\\"action\\":\\"blocks\\",\\"includeText\\":true,\\"offset\\":0,\\"limit\\":20,\\"reviewMode\\":\\"final\\"}\\n  3. {\\"action\\":\\"blocks\\",\\"offset\\":0,\\"limit\\":20,\\"nodeTypes\\":[\\"heading\\",\\"paragraph\\"]}\\n  4. {\\"action\\":\\"text\\"}\\n  5. {\\"action\\":\\"info\\"}\\n  6. {\\"action\\":\\"html_projection\\",\\"reviewMode\\":\\"redline\\",\\"includeSourceMap\\":true}\\n  7. {\\"action\\":\\"markdown_projection\\",\\"reviewMode\\":\\"original\\",\\"scope\\":{\\"kind\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"paragraph-id\\"},\\"includeSourceMap\\":true}",
       "input_schema": {
         "type": "object",
         "properties": {
@@ -57733,7 +57733,7 @@ var init_embedded_tools_generated = __esm(() => {
     },
     {
       "name": "superdoc_mutations",
-      "description": "All steps succeed or all fail; no partial application. Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. Each step has an id, an op, a \\"where\\" clause for targeting ({by:\\"select\\", select:{...}, require:\\"first\\"|\\"exactlyOne\\"|\\"all\\"} or {by:\\"ref\\", ref:\\"...\\"} or {by:\\"block\\", nodeType:\\"paragraph\\", nodeId:\\"...\\"}), and \\"args\\" with operation-specific parameters. Use {by:\\"block\\", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action \\"blocks\\" without relying on text matching. For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:\\"blocks\\" and includeText:true, then rewrite the matching block by nodeId. Use {by:\\"select\\"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. For create steps, \\"where\\" targets an existing anchor block and args.position (\\"before\\" or \\"after\\") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. For format.apply with require \\"all\\", use a node selector to format every heading or paragraph at once: {by:\\"select\\", select:{type:\\"node\\", nodeType:\\"heading\\"}, require:\\"all\\"}. Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. Action \\"preview\\" dry-runs the plan. Action \\"apply\\" executes it. If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"apply\\",\\"atomic\\":true,\\"changeMode\\":\\"direct\\",\\"steps\\":[{\\"id\\":\\"s1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"old term\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"new term\\"}}},{\\"id\\":\\"s2\\",\\"op\\":\\"text.delete\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\" (deprecated)\\"},\\"require\\":\\"all\\"},\\"args\\":{}}]}\\n  2. {\\"action\\":\\"apply\\",\\"steps\\":[{\\"id\\":\\"r1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"<nodeId>\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"Updated clause text.\\"}}},{\\"id\\":\\"f1\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"node\\",\\"nodeType\\":\\"heading\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"color\\":\\"#FF0000\\"}}},{\\"id\\":\\"f2\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"Confidential Information\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"bold\\":true}}}]}",
+      "description": "All steps succeed or all fail; no partial application. Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. Each step has an id, an op, a \\"where\\" clause for targeting ({by:\\"select\\", select:{...}, require:\\"first\\"|\\"exactlyOne\\"|\\"all\\"} or {by:\\"ref\\", ref:\\"...\\"} or {by:\\"block\\", nodeType:\\"paragraph\\", nodeId:\\"...\\"}), and \\"args\\" with operation-specific parameters. Use {by:\\"block\\", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action \\"blocks\\" without relying on text matching. For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:\\"blocks\\" and includeText:true, then rewrite the matching block by nodeId. For a placeholder or name within a tab-separated paragraph, use a text.rewrite where.by:\\"select\\" targeting only the exact placeholder; a whole-block plain-text rewrite omitting tabs deletes those controls. Use {by:\\"select\\"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. For create steps, \\"where\\" targets an existing anchor block and args.position (\\"before\\" or \\"after\\") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. For format.apply with require \\"all\\", use a node selector to format every heading or paragraph at once: {by:\\"select\\", select:{type:\\"node\\", nodeType:\\"heading\\"}, require:\\"all\\"}. Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. Action \\"preview\\" dry-runs the plan. Action \\"apply\\" executes it. If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"apply\\",\\"atomic\\":true,\\"changeMode\\":\\"direct\\",\\"steps\\":[{\\"id\\":\\"s1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"old term\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"new term\\"}}},{\\"id\\":\\"s2\\",\\"op\\":\\"text.delete\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\" (deprecated)\\"},\\"require\\":\\"all\\"},\\"args\\":{}}]}\\n  2. {\\"action\\":\\"apply\\",\\"steps\\":[{\\"id\\":\\"r1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"<nodeId>\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"Updated clause text.\\"}}},{\\"id\\":\\"f1\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"node\\",\\"nodeType\\":\\"heading\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"color\\":\\"#FF0000\\"}}},{\\"id\\":\\"f2\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"Confidential Information\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"bold\\":true}}}]}",
       "input_schema": {
         "type": "object",
         "properties": {
@@ -61469,7 +61469,7 @@ var init_embedded_tools_generated = __esm(() => {
       "type": "function",
       "function": {
         "name": "superdoc_get_content",
-        "description": "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. Action \\"blocks\\" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. When you need to evaluate or rewrite existing paragraphs or clauses, prefer action \\"blocks\\" with includeText:true so you can identify the correct block and then target it by nodeId. Actions \\"text\\", \\"markdown\\", and \\"html\\" return compact strings. Actions \\"markdown_projection\\" and \\"html_projection\\" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. Action \\"info\\" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. The \\"blocks\\" action supports pagination via \\"offset\\" and \\"limit\\", filtering via \\"nodeTypes\\", and numbering projection via \\"reviewMode\\". Other actions ignore pagination and filtering parameters. This tool never modifies the document. Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"blocks\\"}\\n  2. {\\"action\\":\\"blocks\\",\\"includeText\\":true,\\"offset\\":0,\\"limit\\":20,\\"reviewMode\\":\\"final\\"}\\n  3. {\\"action\\":\\"blocks\\",\\"offset\\":0,\\"limit\\":20,\\"nodeTypes\\":[\\"heading\\",\\"paragraph\\"]}\\n  4. {\\"action\\":\\"text\\"}\\n  5. {\\"action\\":\\"info\\"}\\n  6. {\\"action\\":\\"html_projection\\",\\"reviewMode\\":\\"redline\\",\\"includeSourceMap\\":true}\\n  7. {\\"action\\":\\"markdown_projection\\",\\"reviewMode\\":\\"original\\",\\"scope\\":{\\"kind\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"paragraph-id\\"},\\"includeSourceMap\\":true}",
+        "description": "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. Action \\"blocks\\" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Paragraph-class blocks include tabCount, the number of U+0009 tabs in the complete text even if the 80-character preview trims or truncates them. If tabCount is positive, read includeText:true before editing; do not treat a preview space as proof that there is no tab. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. When you need to evaluate or rewrite existing paragraphs or clauses, prefer action \\"blocks\\" with includeText:true so you can identify the correct block and then target it by nodeId. Actions \\"text\\", \\"markdown\\", and \\"html\\" return compact strings. Actions \\"markdown_projection\\" and \\"html_projection\\" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. Action \\"info\\" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. The \\"blocks\\" action supports pagination via \\"offset\\" and \\"limit\\", filtering via \\"nodeTypes\\", and numbering projection via \\"reviewMode\\". Other actions ignore pagination and filtering parameters. This tool never modifies the document. Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"blocks\\"}\\n  2. {\\"action\\":\\"blocks\\",\\"includeText\\":true,\\"offset\\":0,\\"limit\\":20,\\"reviewMode\\":\\"final\\"}\\n  3. {\\"action\\":\\"blocks\\",\\"offset\\":0,\\"limit\\":20,\\"nodeTypes\\":[\\"heading\\",\\"paragraph\\"]}\\n  4. {\\"action\\":\\"text\\"}\\n  5. {\\"action\\":\\"info\\"}\\n  6. {\\"action\\":\\"html_projection\\",\\"reviewMode\\":\\"redline\\",\\"includeSourceMap\\":true}\\n  7. {\\"action\\":\\"markdown_projection\\",\\"reviewMode\\":\\"original\\",\\"scope\\":{\\"kind\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"paragraph-id\\"},\\"includeSourceMap\\":true}",
         "parameters": {
           "type": "object",
           "properties": {
@@ -67351,7 +67351,7 @@ var init_embedded_tools_generated = __esm(() => {
       "type": "function",
       "function": {
         "name": "superdoc_mutations",
-        "description": "All steps succeed or all fail; no partial application. Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. Each step has an id, an op, a \\"where\\" clause for targeting ({by:\\"select\\", select:{...}, require:\\"first\\"|\\"exactlyOne\\"|\\"all\\"} or {by:\\"ref\\", ref:\\"...\\"} or {by:\\"block\\", nodeType:\\"paragraph\\", nodeId:\\"...\\"}), and \\"args\\" with operation-specific parameters. Use {by:\\"block\\", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action \\"blocks\\" without relying on text matching. For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:\\"blocks\\" and includeText:true, then rewrite the matching block by nodeId. Use {by:\\"select\\"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. For create steps, \\"where\\" targets an existing anchor block and args.position (\\"before\\" or \\"after\\") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. For format.apply with require \\"all\\", use a node selector to format every heading or paragraph at once: {by:\\"select\\", select:{type:\\"node\\", nodeType:\\"heading\\"}, require:\\"all\\"}. Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. Action \\"preview\\" dry-runs the plan. Action \\"apply\\" executes it. If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"apply\\",\\"atomic\\":true,\\"changeMode\\":\\"direct\\",\\"steps\\":[{\\"id\\":\\"s1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"old term\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"new term\\"}}},{\\"id\\":\\"s2\\",\\"op\\":\\"text.delete\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\" (deprecated)\\"},\\"require\\":\\"all\\"},\\"args\\":{}}]}\\n  2. {\\"action\\":\\"apply\\",\\"steps\\":[{\\"id\\":\\"r1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"<nodeId>\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"Updated clause text.\\"}}},{\\"id\\":\\"f1\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"node\\",\\"nodeType\\":\\"heading\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"color\\":\\"#FF0000\\"}}},{\\"id\\":\\"f2\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"Confidential Information\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"bold\\":true}}}]}",
+        "description": "All steps succeed or all fail; no partial application. Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. Each step has an id, an op, a \\"where\\" clause for targeting ({by:\\"select\\", select:{...}, require:\\"first\\"|\\"exactlyOne\\"|\\"all\\"} or {by:\\"ref\\", ref:\\"...\\"} or {by:\\"block\\", nodeType:\\"paragraph\\", nodeId:\\"...\\"}), and \\"args\\" with operation-specific parameters. Use {by:\\"block\\", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action \\"blocks\\" without relying on text matching. For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:\\"blocks\\" and includeText:true, then rewrite the matching block by nodeId. For a placeholder or name within a tab-separated paragraph, use a text.rewrite where.by:\\"select\\" targeting only the exact placeholder; a whole-block plain-text rewrite omitting tabs deletes those controls. Use {by:\\"select\\"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. For create steps, \\"where\\" targets an existing anchor block and args.position (\\"before\\" or \\"after\\") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. For format.apply with require \\"all\\", use a node selector to format every heading or paragraph at once: {by:\\"select\\", select:{type:\\"node\\", nodeType:\\"heading\\"}, require:\\"all\\"}. Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. Action \\"preview\\" dry-runs the plan. Action \\"apply\\" executes it. If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"apply\\",\\"atomic\\":true,\\"changeMode\\":\\"direct\\",\\"steps\\":[{\\"id\\":\\"s1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"old term\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"new term\\"}}},{\\"id\\":\\"s2\\",\\"op\\":\\"text.delete\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\" (deprecated)\\"},\\"require\\":\\"all\\"},\\"args\\":{}}]}\\n  2. {\\"action\\":\\"apply\\",\\"steps\\":[{\\"id\\":\\"r1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"<nodeId>\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"Updated clause text.\\"}}},{\\"id\\":\\"f1\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"node\\",\\"nodeType\\":\\"heading\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"color\\":\\"#FF0000\\"}}},{\\"id\\":\\"f2\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"Confidential Information\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"bold\\":true}}}]}",
         "parameters": {
           "type": "object",
           "properties": {
@@ -71089,7 +71089,7 @@ var init_embedded_tools_generated = __esm(() => {
   "tools": [
     {
       "name": "superdoc_get_content",
-      "description": "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. Action \\"blocks\\" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. When you need to evaluate or rewrite existing paragraphs or clauses, prefer action \\"blocks\\" with includeText:true so you can identify the correct block and then target it by nodeId. Actions \\"text\\", \\"markdown\\", and \\"html\\" return compact strings. Actions \\"markdown_projection\\" and \\"html_projection\\" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. Action \\"info\\" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. The \\"blocks\\" action supports pagination via \\"offset\\" and \\"limit\\", filtering via \\"nodeTypes\\", and numbering projection via \\"reviewMode\\". Other actions ignore pagination and filtering parameters. This tool never modifies the document. Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"blocks\\"}\\n  2. {\\"action\\":\\"blocks\\",\\"includeText\\":true,\\"offset\\":0,\\"limit\\":20,\\"reviewMode\\":\\"final\\"}\\n  3. {\\"action\\":\\"blocks\\",\\"offset\\":0,\\"limit\\":20,\\"nodeTypes\\":[\\"heading\\",\\"paragraph\\"]}\\n  4. {\\"action\\":\\"text\\"}\\n  5. {\\"action\\":\\"info\\"}\\n  6. {\\"action\\":\\"html_projection\\",\\"reviewMode\\":\\"redline\\",\\"includeSourceMap\\":true}\\n  7. {\\"action\\":\\"markdown_projection\\",\\"reviewMode\\":\\"original\\",\\"scope\\":{\\"kind\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"paragraph-id\\"},\\"includeSourceMap\\":true}",
+      "description": "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. Action \\"blocks\\" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Paragraph-class blocks include tabCount, the number of U+0009 tabs in the complete text even if the 80-character preview trims or truncates them. If tabCount is positive, read includeText:true before editing; do not treat a preview space as proof that there is no tab. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. When you need to evaluate or rewrite existing paragraphs or clauses, prefer action \\"blocks\\" with includeText:true so you can identify the correct block and then target it by nodeId. Actions \\"text\\", \\"markdown\\", and \\"html\\" return compact strings. Actions \\"markdown_projection\\" and \\"html_projection\\" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. Action \\"info\\" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. The \\"blocks\\" action supports pagination via \\"offset\\" and \\"limit\\", filtering via \\"nodeTypes\\", and numbering projection via \\"reviewMode\\". Other actions ignore pagination and filtering parameters. This tool never modifies the document. Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"blocks\\"}\\n  2. {\\"action\\":\\"blocks\\",\\"includeText\\":true,\\"offset\\":0,\\"limit\\":20,\\"reviewMode\\":\\"final\\"}\\n  3. {\\"action\\":\\"blocks\\",\\"offset\\":0,\\"limit\\":20,\\"nodeTypes\\":[\\"heading\\",\\"paragraph\\"]}\\n  4. {\\"action\\":\\"text\\"}\\n  5. {\\"action\\":\\"info\\"}\\n  6. {\\"action\\":\\"html_projection\\",\\"reviewMode\\":\\"redline\\",\\"includeSourceMap\\":true}\\n  7. {\\"action\\":\\"markdown_projection\\",\\"reviewMode\\":\\"original\\",\\"scope\\":{\\"kind\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"paragraph-id\\"},\\"includeSourceMap\\":true}",
       "parameters": {
         "type": "object",
         "properties": {
@@ -77115,7 +77115,7 @@ var init_embedded_tools_generated = __esm(() => {
     },
     {
       "name": "superdoc_mutations",
-      "description": "All steps succeed or all fail; no partial application. Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. Each step has an id, an op, a \\"where\\" clause for targeting ({by:\\"select\\", select:{...}, require:\\"first\\"|\\"exactlyOne\\"|\\"all\\"} or {by:\\"ref\\", ref:\\"...\\"} or {by:\\"block\\", nodeType:\\"paragraph\\", nodeId:\\"...\\"}), and \\"args\\" with operation-specific parameters. Use {by:\\"block\\", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action \\"blocks\\" without relying on text matching. For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:\\"blocks\\" and includeText:true, then rewrite the matching block by nodeId. Use {by:\\"select\\"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. For create steps, \\"where\\" targets an existing anchor block and args.position (\\"before\\" or \\"after\\") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. For format.apply with require \\"all\\", use a node selector to format every heading or paragraph at once: {by:\\"select\\", select:{type:\\"node\\", nodeType:\\"heading\\"}, require:\\"all\\"}. Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. Action \\"preview\\" dry-runs the plan. Action \\"apply\\" executes it. If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"apply\\",\\"atomic\\":true,\\"changeMode\\":\\"direct\\",\\"steps\\":[{\\"id\\":\\"s1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"old term\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"new term\\"}}},{\\"id\\":\\"s2\\",\\"op\\":\\"text.delete\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\" (deprecated)\\"},\\"require\\":\\"all\\"},\\"args\\":{}}]}\\n  2. {\\"action\\":\\"apply\\",\\"steps\\":[{\\"id\\":\\"r1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"<nodeId>\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"Updated clause text.\\"}}},{\\"id\\":\\"f1\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"node\\",\\"nodeType\\":\\"heading\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"color\\":\\"#FF0000\\"}}},{\\"id\\":\\"f2\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"Confidential Information\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"bold\\":true}}}]}",
+      "description": "All steps succeed or all fail; no partial application. Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. Each step has an id, an op, a \\"where\\" clause for targeting ({by:\\"select\\", select:{...}, require:\\"first\\"|\\"exactlyOne\\"|\\"all\\"} or {by:\\"ref\\", ref:\\"...\\"} or {by:\\"block\\", nodeType:\\"paragraph\\", nodeId:\\"...\\"}), and \\"args\\" with operation-specific parameters. Use {by:\\"block\\", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action \\"blocks\\" without relying on text matching. For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:\\"blocks\\" and includeText:true, then rewrite the matching block by nodeId. For a placeholder or name within a tab-separated paragraph, use a text.rewrite where.by:\\"select\\" targeting only the exact placeholder; a whole-block plain-text rewrite omitting tabs deletes those controls. Use {by:\\"select\\"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. For create steps, \\"where\\" targets an existing anchor block and args.position (\\"before\\" or \\"after\\") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. For format.apply with require \\"all\\", use a node selector to format every heading or paragraph at once: {by:\\"select\\", select:{type:\\"node\\", nodeType:\\"heading\\"}, require:\\"all\\"}. Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. Action \\"preview\\" dry-runs the plan. Action \\"apply\\" executes it. If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.\\n\\nEXAMPLES:\\n  1. {\\"action\\":\\"apply\\",\\"atomic\\":true,\\"changeMode\\":\\"direct\\",\\"steps\\":[{\\"id\\":\\"s1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"old term\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"new term\\"}}},{\\"id\\":\\"s2\\",\\"op\\":\\"text.delete\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\" (deprecated)\\"},\\"require\\":\\"all\\"},\\"args\\":{}}]}\\n  2. {\\"action\\":\\"apply\\",\\"steps\\":[{\\"id\\":\\"r1\\",\\"op\\":\\"text.rewrite\\",\\"where\\":{\\"by\\":\\"block\\",\\"nodeType\\":\\"paragraph\\",\\"nodeId\\":\\"<nodeId>\\"},\\"args\\":{\\"replacement\\":{\\"text\\":\\"Updated clause text.\\"}}},{\\"id\\":\\"f1\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"node\\",\\"nodeType\\":\\"heading\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"color\\":\\"#FF0000\\"}}},{\\"id\\":\\"f2\\",\\"op\\":\\"format.apply\\",\\"where\\":{\\"by\\":\\"select\\",\\"select\\":{\\"type\\":\\"text\\",\\"pattern\\":\\"Confidential Information\\"},\\"require\\":\\"all\\"},\\"args\\":{\\"inline\\":{\\"bold\\":true}}}]}",
       "parameters": {
         "type": "object",
         "properties": {
@@ -80918,13 +80918,13 @@ var init_embedded_tools_generated = __esm(() => {
 
 Every editing tool needs a **target** telling the API *where* to apply the change. There are three ways to get one:
 
-- **From blocks data**: Each block has a \`ref\` (pass directly to superdoc_edit or superdoc_format), a \`nodeId\` (for building \`at\` positions with superdoc_create or \`where: {by: "block", ...}\` in superdoc_mutations), and optional full \`text\` when you call \`superdoc_get_content({action: "blocks", includeText: true})\`.
+- **From blocks data**: Each block has a \`ref\` (pass directly to superdoc_edit or superdoc_format), a \`nodeId\` (for building \`at\` positions with superdoc_create or \`where: {by: "block", ...}\` in superdoc_mutations), and optional full \`text\` when you call \`superdoc_get_content({action: "blocks", includeText: true})\`. Paragraph-class blocks have \`tabCount\` for the complete text; a compact \`textPreview\` can trim or truncate tabs. If \`tabCount > 0\`, read with \`includeText: true\` before editing.
 - **From superdoc_search**: Returns \`handle.ref\` covering the matched text. Use search when you need to find text patterns, not when you already know which block to target.
 - **From superdoc_create**: Returns \`nodeId\` and \`ref\`. The ref is valid for one immediate format call. For subsequent operations, re-fetch blocks to get fresh refs.
 
 **Refs expire after any mutation** between separate tool calls. Within a superdoc_mutations batch, selectors resolve automatically — no manual re-searching between steps.
 
-**Critical targeting rule:** when rewriting an entire paragraph, clause, or other known block, first read \`superdoc_get_content({action: "blocks", includeText: true})\`, identify the block's \`nodeId\`, then use \`where: {by: "block", nodeType, nodeId}\` in \`superdoc_mutations\`. Do NOT use a shortened text selector to rewrite a whole clause.
+**Critical targeting rule:** when rewriting an entire paragraph, clause, or other known block, first read \`superdoc_get_content({action: "blocks", includeText: true})\`, identify the block's \`nodeId\`, then use \`where: {by: "block", nodeType, nodeId}\` in \`superdoc_mutations\`. Do NOT use a shortened text selector to rewrite a whole clause. Conversely, to change only a name or placeholder, select that exact text with \`superdoc_search\` and call \`superdoc_edit({action: "replace", ref: "<handle.ref>", text: "new name"})\`, or use a \`text.rewrite\` step with \`where: {by: "select", select: {type: "text", pattern: "old name"}, require: "exactlyOne"}\`. A whole-block plain-text rewrite that omits tabs deletes them; do not use it for a placeholder edit. Preserving tabs does not guarantee a visually aligned column if longer text crosses tab stops.
 
 ## Citation-grade output reads
 
@@ -81403,13 +81403,13 @@ One format.apply step per block. Combine \`inline\`, \`alignment\`, and \`scope:
 
 Every editing tool needs a **target** telling the API *where* to apply the change. There are three ways to get one:
 
-- **From blocks data**: Each block has a \`ref\` (pass directly to superdoc_edit or superdoc_format), a \`nodeId\` (for building \`at\` positions with superdoc_create or \`where: {by: "block", ...}\` in superdoc_mutations), and optional full \`text\` when you call \`superdoc_get_content({action: "blocks", includeText: true})\`.
+- **From blocks data**: Each block has a \`ref\` (pass directly to superdoc_edit or superdoc_format), a \`nodeId\` (for building \`at\` positions with superdoc_create or \`where: {by: "block", ...}\` in superdoc_mutations), and optional full \`text\` when you call \`superdoc_get_content({action: "blocks", includeText: true})\`. Paragraph-class blocks have \`tabCount\` for the complete text; a compact \`textPreview\` can trim or truncate tabs. If \`tabCount > 0\`, read with \`includeText: true\` before editing.
 - **From superdoc_search**: Returns \`handle.ref\` covering the matched text. Use search when you need to find text patterns, not when you already know which block to target.
 - **From superdoc_create**: Returns \`nodeId\` and \`ref\`. The ref is valid for one immediate format call. For subsequent operations, re-fetch blocks to get fresh refs.
 
 **Refs expire after any mutation** between separate tool calls. Within a superdoc_mutations batch, selectors resolve automatically — no manual re-searching between steps.
 
-**Critical targeting rule:** when rewriting an entire paragraph, clause, or other known block, first read \`superdoc_get_content({action: "blocks", includeText: true})\`, identify the block's \`nodeId\`, then use \`where: {by: "block", nodeType, nodeId}\` in \`superdoc_mutations\`. Do NOT use a shortened text selector to rewrite a whole clause.
+**Critical targeting rule:** when rewriting an entire paragraph, clause, or other known block, first read \`superdoc_get_content({action: "blocks", includeText: true})\`, identify the block's \`nodeId\`, then use \`where: {by: "block", nodeType, nodeId}\` in \`superdoc_mutations\`. Do NOT use a shortened text selector to rewrite a whole clause. Conversely, to change only a name or placeholder, select that exact text with \`superdoc_search\` and call \`superdoc_edit({action: "replace", ref: "<handle.ref>", text: "new name"})\`, or use a \`text.rewrite\` step with \`where: {by: "select", select: {type: "text", pattern: "old name"}, require: "exactlyOne"}\`. A whole-block plain-text rewrite that omits tabs deletes them; do not use it for a placeholder edit. Preserving tabs does not guarantee a visually aligned column if longer text crosses tab stops.
 
 ## Citation-grade output reads
 
@@ -82195,6 +82195,7 @@ function normalizeSnapshotBlock(value, fallbackOrdinal, blockTextLimit) {
     nodeType: asString(rec.nodeType, "paragraph"),
     text,
     textPreview,
+    ...typeof rec.tabCount === "number" && Number.isInteger(rec.tabCount) && rec.tabCount >= 0 ? { tabCount: rec.tabCount } : {},
     styleId: typeof rec.styleId === "string" ? rec.styleId : null,
     headingLevel: typeof rec.headingLevel === "number" ? rec.headingLevel : undefined,
     ...asRecord(rec.numbering) ? {
@@ -92894,7 +92895,7 @@ var init_actions = __esm(() => {
       operations: ["comments.create"]
     },
     rewrite_block: {
-      hint: "selector, text, changeMode? — REPLACES the whole block text using the document API's formatting preservation. For appending a NEW paragraph/clause use insert_paragraphs, and for small wording edits prefer replace_text with a minimal find span",
+      hint: "selector, text, changeMode? — REPLACES the whole block text. Omitted tab controls are deleted: for a tab-aligned paragraph, use replace_text with a minimal find span to change a name/placeholder instead. For appending a NEW paragraph/clause use insert_paragraphs",
       group: "Text/structure actions",
       groupOrder: 7,
       args: ["text", "selector", "changeMode", "evidence"],
@@ -96324,7 +96325,7 @@ var init_operation_definitions = __esm(() => {
     },
     get_content: {
       toolName: "superdoc_get_content",
-      description: "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. " + 'Action "blocks" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. ' + 'When you need to evaluate or rewrite existing paragraphs or clauses, prefer action "blocks" with includeText:true so you can identify the correct block and then target it by nodeId. ' + 'Actions "text", "markdown", and "html" return compact strings. Actions "markdown_projection" and "html_projection" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. ' + "Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. " + 'Action "info" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. ' + 'The "blocks" action supports pagination via "offset" and "limit", filtering via "nodeTypes", and numbering projection via "reviewMode". Other actions ignore pagination and filtering parameters. ' + "This tool never modifies the document. " + "Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.",
+      description: "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. " + 'Action "blocks" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Paragraph-class blocks include tabCount, the number of U+0009 tabs in the complete text even if the 80-character preview trims or truncates them. If tabCount is positive, read includeText:true before editing; do not treat a preview space as proof that there is no tab. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. ' + 'When you need to evaluate or rewrite existing paragraphs or clauses, prefer action "blocks" with includeText:true so you can identify the correct block and then target it by nodeId. ' + 'Actions "text", "markdown", and "html" return compact strings. Actions "markdown_projection" and "html_projection" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. ' + "Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. " + 'Action "info" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. ' + 'The "blocks" action supports pagination via "offset" and "limit", filtering via "nodeTypes", and numbering projection via "reviewMode". Other actions ignore pagination and filtering parameters. ' + "This tool never modifies the document. " + "Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.",
       inputExamples: [
         { action: "blocks" },
         { action: "blocks", includeText: true, offset: 0, limit: 20, reviewMode: "final" },
@@ -96616,7 +96617,7 @@ Complete new body.`,
     section: { toolName: "superdoc_section", description: "Page layout, margins, columns" },
     mutations: {
       toolName: "superdoc_mutations",
-      description: "All steps succeed or all fail; no partial application. " + "Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. " + "Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. " + 'Each step has an id, an op, a "where" clause for targeting ({by:"select", select:{...}, require:"first"|"exactlyOne"|"all"} or {by:"ref", ref:"..."} or {by:"block", nodeType:"paragraph", nodeId:"..."}), and "args" with operation-specific parameters. ' + 'Use {by:"block", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action "blocks" without relying on text matching. ' + 'For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:"blocks" and includeText:true, then rewrite the matching block by nodeId. ' + 'Use {by:"select"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. ' + 'For create steps, "where" targets an existing anchor block and args.position ("before" or "after") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. ' + 'For format.apply with require "all", use a node selector to format every heading or paragraph at once: {by:"select", select:{type:"node", nodeType:"heading"}, require:"all"}. ' + "Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. " + 'Action "preview" dry-runs the plan. Action "apply" executes it. ' + "If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. " + "Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.",
+      description: "All steps succeed or all fail; no partial application. " + "Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. " + "Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. " + 'Each step has an id, an op, a "where" clause for targeting ({by:"select", select:{...}, require:"first"|"exactlyOne"|"all"} or {by:"ref", ref:"..."} or {by:"block", nodeType:"paragraph", nodeId:"..."}), and "args" with operation-specific parameters. ' + 'Use {by:"block", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action "blocks" without relying on text matching. ' + 'For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:"blocks" and includeText:true, then rewrite the matching block by nodeId. ' + 'For a placeholder or name within a tab-separated paragraph, use a text.rewrite where.by:"select" targeting only the exact placeholder; a whole-block plain-text rewrite omitting tabs deletes those controls. ' + 'Use {by:"select"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. ' + 'For create steps, "where" targets an existing anchor block and args.position ("before" or "after") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. ' + 'For format.apply with require "all", use a node selector to format every heading or paragraph at once: {by:"select", select:{type:"node", nodeType:"heading"}, require:"all"}. ' + "Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. " + 'Action "preview" dry-runs the plan. Action "apply" executes it. ' + "If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. " + "Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.",
       inputExamples: [
         {
           action: "apply",
@@ -109129,6 +109130,11 @@ var init_schemas4 = __esm(() => {
               oneOf: [{ type: "string" }, { type: "null" }],
               description: "Full flattened block text when requested with includeText."
             },
+            tabCount: {
+              type: "integer",
+              minimum: 0,
+              description: "Tabs in complete paragraph text, even beyond the preview."
+            },
             isEmpty: { type: "boolean" },
             styleId: { oneOf: [{ type: "string" }, { type: "null" }], description: "Named paragraph style." },
             fontFamily: { type: "string", description: "Font family from first text run." },
@@ -124582,6 +124588,13 @@ function parseItem(source, item, ctx) {
       return [];
     case "r":
       return parseRun(source, item, ctx);
+    case "br":
+      if (!isWordprocessingElement(item, ctx.namespaceBindings)) {
+        return [buildDescendingContainer(source, item, ctx, "unknown", "fail-closed")];
+      }
+      return [makeContainerPiece(item, ctx, "unknown", "fail-closed", [
+        buildControlPiece(item, ctx, null, item.byteStart, item.byteEnd, item.charStart, item.charEnd, "", "")
+      ])];
     case "ins":
     case "del":
     case "moveFrom":
@@ -125588,6 +125601,9 @@ function projectElement(xml, elementStart, element, deleted, instruction, namesp
   if (element.selfClosing) {
     if (localName === "r")
       projectRun2(xml, elementStart, element, deleted, instruction, namespaceScopes, collector);
+    if (localName === "br" && isWordprocessingElement2(xml, elementStart, element, namespaceScopes, collector.inferredWordPrefix))
+      appendControl(collector, `
+`, deleted);
     return;
   }
   switch (localName) {
@@ -125599,6 +125615,16 @@ function projectElement(xml, elementStart, element, deleted, instruction, namesp
     case "r":
       projectRun2(xml, elementStart, element, deleted, instruction, namespaceScopes, collector);
       return;
+    case "br":
+      if (isWordprocessingElement2(xml, elementStart, element, namespaceScopes, collector.inferredWordPrefix)) {
+        appendControl(collector, `
+`, deleted);
+        return;
+      }
+      withNamespaceScope(namespaceScopes, elementStart, element.openEnd, () => {
+        projectChildSequence(xml, element.openEnd, element.closeStart, deleted, instruction, namespaceScopes, collector);
+      });
+      return;
     case "del":
     case "moveFrom":
       withNamespaceScope(namespaceScopes, elementStart, element.openEnd, () => {
@@ -133951,6 +133977,50 @@ var init_note_xml_validation = __esm(() => {
 });
 
 // ../../../v2/document-compare/src/replayability.ts
+function preservedBookmarkRunTokens(xml) {
+  const markerTags = [...xml.matchAll(/<([\w.-]+:)?bookmark(Start|End)\b[^<>]*?\/>/g)];
+  const markerOpenings = [...xml.matchAll(/<(?:[\w.-]+:)?bookmark(?:Start|End)\b/g)];
+  if (markerTags.length !== 2 || markerOpenings.length !== 2 || markerTags[0][2] !== "Start" || markerTags[1][2] !== "End")
+    return null;
+  let valid = true;
+  let depth = 0;
+  const markers = [];
+  const parser = new import_saxes3.SaxesParser({
+    xmlns: true,
+    additionalNamespaces: replayAdditionalNamespaces(xml)
+  });
+  parser.on("error", () => {
+    valid = false;
+  });
+  parser.on("opentag", (tag) => {
+    depth += 1;
+    if (tag.local !== "bookmarkStart" && tag.local !== "bookmarkEnd")
+      return;
+    const attributes = Object.values(tag.attributes);
+    const id = attributes.find((attribute) => attribute.uri === W_NS && attribute.local === "id")?.value;
+    const name = attributes.find((attribute) => attribute.uri === W_NS && attribute.local === "name")?.value ?? null;
+    if (tag.uri !== W_NS || !tag.isSelfClosing || depth !== 2 || !id || !/^\d+$/.test(id) || tag.local === "bookmarkStart" && !name || tag.local === "bookmarkEnd" && name !== null)
+      valid = false;
+    markers.push({ kind: tag.local, id: id ?? "", name });
+  });
+  parser.on("closetag", () => {
+    depth -= 1;
+  });
+  try {
+    parser.write(`<replay>${xml}</replay>`).close();
+  } catch {
+    valid = false;
+  }
+  if (!valid || depth !== 0 || markers.length !== 2 || markers[0].kind !== "bookmarkStart" || markers[1].kind !== "bookmarkEnd" || markers[0].id !== markers[1].id)
+    return null;
+  return {
+    startXml: markerTags[0][0],
+    endXml: markerTags[1][0],
+    leadingXml: xml.slice(0, markerTags[0].index),
+    trailingXml: xml.slice(markerTags[1].index + markerTags[1][0].length),
+    strippedXml: xml.slice(0, markerTags[0].index) + xml.slice(markerTags[0].index + markerTags[0][0].length, markerTags[1].index) + xml.slice(markerTags[1].index + markerTags[1][0].length)
+  };
+}
 function replayAdditionalNamespaces(xml) {
   const implicitNamespaces = { w: W_NS };
   const firstElement = /<([A-Za-z_][\w.-]*)(?::[A-Za-z_][\w.-]*)?(?=[\s/>])/.exec(xml);
@@ -134078,6 +134148,13 @@ function parseDirectRunSequence(xml, allowRevisions) {
       originalText += value;
     }
   };
+  const isProofingBoundary = (tag) => {
+    if (tag.uri !== W_NS || tag.local !== "proofErr" || !tag.isSelfClosing)
+      return false;
+    const attributes = Object.values(tag.attributes);
+    const typeAttributes = attributes.filter((attribute) => typeof attribute !== "string" && attribute.uri === W_NS && attribute.local === "type");
+    return typeAttributes.length === 1 && typeof typeAttributes[0] !== "string" && PROOFING_BOUNDARY_TYPES.has(typeAttributes[0].value) && attributes.every((attribute) => typeof attribute !== "string" && (attribute === typeAttributes[0] || attribute.uri === "http://www.w3.org/2000/xmlns/" && (attribute.local === tag.prefix || attribute.local === "w" || tag.prefix === "" && attribute.local === "xmlns") && attribute.value === W_NS));
+  };
   const parser = new import_saxes3.SaxesParser({
     xmlns: true,
     additionalNamespaces: replayAdditionalNamespaces(xml)
@@ -134094,6 +134171,10 @@ function parseDirectRunSequence(xml, allowRevisions) {
       return;
     }
     if (parent === "wrapper") {
+      if (isProofingBoundary(tag)) {
+        stack.push("control");
+        return;
+      }
       rootCount += 1;
       if (tag.uri === W_NS && tag.local === "r") {
         stack.push("run");
@@ -134124,6 +134205,10 @@ function parseDirectRunSequence(xml, allowRevisions) {
       return;
     }
     if (parent === "revision") {
+      if (isProofingBoundary(tag)) {
+        stack.push("control");
+        return;
+      }
       if (tag.uri !== W_NS || tag.local !== "r")
         valid = false;
       activeRevisionRunCount += 1;
@@ -134550,13 +134635,14 @@ function validateRunContents(xml, options) {
   if (xml === "")
     return { ok: true };
   const replayXml = stripAllowedNoteReferences(xml, options);
-  if (replayXml === null || UNSUPPORTED_XML.test(replayXml) || RELATIONSHIP_REFERENCE.test(replayXml)) {
+  const withoutBookmarks = replayXml !== null && /<(?:[\w.-]+:)?bookmark(?:Start|End)\b/.test(replayXml) ? preservedBookmarkRunTokens(replayXml)?.strippedXml ?? null : replayXml;
+  if (withoutBookmarks === null || UNSUPPORTED_XML.test(withoutBookmarks) || RELATIONSHIP_REFERENCE.test(withoutBookmarks)) {
     return { ok: false, reason: "target runs require unsupported structural or relationship replay" };
   }
-  const namespaceResult = validateReplayNamespaces(replayXml, "target runs use namespace prefixes that cannot be replayed safely");
+  const namespaceResult = validateReplayNamespaces(withoutBookmarks.replace(PROOFING_BOUNDARY_TAG_RE, ""), "target runs use namespace prefixes that cannot be replayed safely");
   if (!namespaceResult.ok)
     return namespaceResult;
-  if (!parseDirectRunSequence(replayXml, false)) {
+  if (!parseDirectRunSequence(withoutBookmarks, false)) {
     return { ok: false, reason: "target runs contain unsupported inline markup" };
   }
   return { ok: true };
@@ -134580,7 +134666,7 @@ function validateCompareReplayPayload(payload, options = {}) {
     if (payload.targetRevisionReplay.policy !== "preserve-target-revision-set" || payload.targetRunXml === undefined) {
       return { ok: false, reason: "target revision replay policy is incomplete" };
     }
-    const namespaceResult = validateReplayNamespaces(payload.targetRunXml, "target revision runs use namespace prefixes that cannot be replayed safely");
+    const namespaceResult = validateReplayNamespaces(payload.targetRunXml.replace(PROOFING_BOUNDARY_TAG_RE, ""), "target revision runs use namespace prefixes that cannot be replayed safely");
     if (!namespaceResult.ok)
       return namespaceResult;
     const inspected = inspectDirectParagraphRevisionRuns(payload.targetRunXml);
@@ -134600,12 +134686,14 @@ function validateCompareReplayPayload(payload, options = {}) {
   }
   return { ok: true };
 }
-var import_saxes3, UNSUPPORTED_XML, RELATIONSHIP_REFERENCE, W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", DIRECT_RUN_PROPERTY_ELEMENTS;
+var import_saxes3, UNSUPPORTED_XML, RELATIONSHIP_REFERENCE, W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", PROOFING_BOUNDARY_TYPES, PROOFING_BOUNDARY_TAG_RE, DIRECT_RUN_PROPERTY_ELEMENTS;
 var init_replayability = __esm(() => {
   init_note_xml_validation();
   import_saxes3 = __toESM(require_saxes(), 1);
-  UNSUPPORTED_XML = /<(?:[\w.-]+:)?(?:hyperlink|drawing|pict|object|fldSimple|fldChar|instrText|commentReference|commentRangeStart|commentRangeEnd|bookmarkStart|bookmarkEnd|permStart|permEnd|sdt|customXml|oMath|oMathPara|footnoteReference|endnoteReference|ins|del|moveFrom|moveTo|pPrChange|rPrChange|sectPr)\b/i;
+  UNSUPPORTED_XML = /<(?:[\w.-]+:)?(?:hyperlink|drawing|pict|object|fldSimple|fldChar|instrText|commentReference|commentRangeStart|commentRangeEnd|permStart|permEnd|sdt|customXml|oMath|oMathPara|footnoteReference|endnoteReference|ins|del|moveFrom|moveTo|pPrChange|rPrChange|sectPr)\b/i;
   RELATIONSHIP_REFERENCE = /\s(?:r:id|r:embed|r:link)\s*=/i;
+  PROOFING_BOUNDARY_TYPES = new Set(["spellStart", "spellEnd", "gramStart", "gramEnd"]);
+  PROOFING_BOUNDARY_TAG_RE = /<(?:[A-Za-z_][\w.-]*:)?proofErr\b(?:[^>"']|"[^"]*"|'[^']*')*\/>/g;
   DIRECT_RUN_PROPERTY_ELEMENTS = new Set([
     "rStyle",
     "rFonts",
@@ -134745,7 +134833,10 @@ function canonicalName(namespace, localName2) {
 }
 function computeRunSignature(runXml) {
   const canonicalXml = canonicalizeXmlForSignature(runXml);
-  const normalized = normalizeRunXmlForSignature(canonicalXml.replace(REVISION_ATTR_RE, "").replace(COMMENT_MARKUP_RE, (markup, name, attributes) => isWordprocessingElement3(name, attributes, canonicalXml) ? "" : markup).replace(NOTE_REFERENCE_MARKUP_RE, (markup, runName, runAttributes, _rPrName, nestedName, nestedAttributes, standaloneName, standaloneAttributes) => {
+  const normalized = normalizeRunXmlForSignature(canonicalXml.replace(REVISION_ATTR_RE, (attribute, offset, xml) => {
+    const precedingTag = xml.slice(xml.lastIndexOf("<", offset), offset);
+    return /^<w:proofErr(?:\s|$)/.test(precedingTag) ? attribute : "";
+  }).replace(REVISION_ELEMENT_RE, (markup) => markup.replace(REVISION_ID_ATTR_RE, "")).replace(COMMENT_MARKUP_RE, (markup, name, attributes) => isWordprocessingElement3(name, attributes, canonicalXml) ? "" : markup).replace(NOTE_REFERENCE_MARKUP_RE, (markup, runName, runAttributes, _rPrName, nestedName, nestedAttributes, standaloneName, standaloneAttributes) => {
     const name = nestedName ?? standaloneName;
     const attributes = nestedAttributes ?? standaloneAttributes;
     if (!isWordprocessingElement3(name, attributes, canonicalXml))
@@ -134772,7 +134863,7 @@ function normalizeRunXmlForSignature(runXml) {
       continue;
     const index = match.index ?? 0;
     if (index > lastIndex) {
-      const interstitial = runXml.slice(lastIndex, index);
+      const interstitial = stripProofingBoundaries(runXml.slice(lastIndex, index));
       if (interstitial.trim().length > 0) {
         pieces.push(interstitial);
         activeTextProperties = "";
@@ -134801,12 +134892,15 @@ function normalizeRunXmlForSignature(runXml) {
   if (!sawRun)
     return runXml;
   if (lastIndex < runXml.length) {
-    const trailing = runXml.slice(lastIndex);
+    const trailing = stripProofingBoundaries(runXml.slice(lastIndex));
     if (trailing.trim().length > 0)
       pieces.push(trailing);
   }
   return pieces.join("");
 }
+function stripProofingBoundaries(xml) {
+  return xml.replace(PROOFING_BOUNDARY_MARKUP_RE, "");
+}
 function normalizeRunControls(content, namespaceContext) {
   return [...content.matchAll(RUN_CONTROL_RE)].filter((match) => isWordprocessingElement3(match[1], match[3], namespaceContext)).map((match) => {
     const attributes = [...match[3].matchAll(ATTRIBUTE_RE)].filter((attribute) => attribute[1] !== "xmlns" && !attribute[1].startsWith("xmlns:")).map((attribute) => {
@@ -134839,10 +134933,13 @@ function isWordprocessingElement3(name, attributes, namespaceContext) {
     return true;
   return (declaration[2] ?? declaration[3] ?? "") === WORDPROCESSINGML_NAMESPACE2;
 }
-var REVISION_ATTR_RE, COMMENT_MARKUP_RE, NOTE_REFERENCE_MARKUP_RE, RUN_RE, RUN_PROPERTIES_RE, EMPTY_RUN_PROPERTIES_RE, TEXTISH_RE, RUN_CONTROL_RE, ATTRIBUTE_RE, WORDPROCESSINGML_NAMESPACE2 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORDPROCESSINGML_2010_NAMESPACE = "http://schemas.microsoft.com/office/word/2010/wordml", MARKUP_COMPATIBILITY_NAMESPACE = "http://schemas.openxmlformats.org/markup-compatibility/2006", XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace", XML_TAG_RE;
+var REVISION_ATTR_RE, REVISION_ELEMENT_RE, REVISION_ID_ATTR_RE, COMMENT_MARKUP_RE, PROOFING_BOUNDARY_MARKUP_RE, NOTE_REFERENCE_MARKUP_RE, RUN_RE, RUN_PROPERTIES_RE, EMPTY_RUN_PROPERTIES_RE, TEXTISH_RE, RUN_CONTROL_RE, ATTRIBUTE_RE, WORDPROCESSINGML_NAMESPACE2 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORDPROCESSINGML_2010_NAMESPACE = "http://schemas.microsoft.com/office/word/2010/wordml", MARKUP_COMPATIBILITY_NAMESPACE = "http://schemas.openxmlformats.org/markup-compatibility/2006", XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace", XML_TAG_RE;
 var init_run_signature = __esm(() => {
-  REVISION_ATTR_RE = /\s+(?:w:rsid\w*|w14:paraId|w14:textId|w:id)="[^"]*"/g;
+  REVISION_ATTR_RE = /\s+(?:w:rsid\w*|w14:paraId|w14:textId)="[^"]*"/g;
+  REVISION_ELEMENT_RE = /<w:(?:ins|del|moveFrom|moveTo)\b[^>]*>/g;
+  REVISION_ID_ATTR_RE = /\s+w:id="[^"]*"/g;
   COMMENT_MARKUP_RE = /<((?:[\w.-]+:)?(?:commentRangeStart|commentRangeEnd|commentReference))\b([^>]*)\/>/g;
+  PROOFING_BOUNDARY_MARKUP_RE = /<w:proofErr w:type="(?:spellStart|spellEnd|gramStart|gramEnd)"\/>/g;
   NOTE_REFERENCE_MARKUP_RE = /<((?:[\w.-]+:)?r)\b([^>]*)>(?:<((?:[\w.-]+:)?rPr)\b[^>]*(?:\/>|>[\s\S]*?<\/\3>))?<((?:[\w.-]+:)?(?:footnoteReference|endnoteReference))\b([^>]*)\/><\/\1>|<((?:[\w.-]+:)?(?:footnoteReference|endnoteReference))\b([^>]*)\/>/g;
   RUN_RE = /<((?:[\w.-]+:)?r)\b([^>]*)>([\s\S]*?)<\/\1>/g;
   RUN_PROPERTIES_RE = /<((?:[\w.-]+:)?rPr)\b([^>]*)(?:\/>|>[\s\S]*?<\/\1>)/g;
@@ -141958,7 +142055,7 @@ var init_story_slice = __esm(() => {
   init_source_coverage_chunks();
   DEFAULT_MAX_XML_BYTES = 64 * 1024;
   TEXT_DECODER = new TextDecoder("utf-8", { fatal: false });
-  NODE_BUFFER = typeof globalThis !== "undefined" && typeof globalThis.Buffer?.byteLength === "function" ? globalThis.Buffer : null;
+  NODE_BUFFER = typeof globalThis !== "undefined" && typeof globalThis.process?.versions?.node === "string" && typeof globalThis.Buffer?.byteLength === "function" ? globalThis.Buffer : null;
   CHUNK_SPAN_CACHE = new WeakMap;
 });
 
@@ -178481,6 +178578,37 @@ function canonicalizeDependencyValue(value) {
   }
   return value;
 }
+function locateSingleResidentBodyChild(state, storyId, partUri, chunk, paragraphByteStart, paragraphByteEnd, containingBodyChildOrdinal) {
+  const story = state.stories.get(storyId)?.descriptor;
+  const part = state.parts.get(partUri)?.descriptor;
+  if (storyId !== state.mainStoryId || story?.storyId !== storyId || story.storyKind !== "main" || story.ownerPartId !== partUri || story.ownerPartUri !== partUri || part?.partId !== partUri || part.partUri !== partUri || chunk.storyId !== storyId || chunk.partUri !== partUri || chunk.storyRevision !== story.revision || !state.packageBytes.has(partUri))
+    return null;
+  const residentByteLength = state.packageBytes.byteLength(partUri);
+  const { byteStart, byteEnd, bodyChildStartOrdinal, bodyChildEndOrdinal, contentBlockStartOrdinal, contentBlockEndOrdinal, firstChildKind, lastChildKind, bodyChildCount, contentBlockCount, markerChildCount, opaqueAnchorCount, containsTrivia, triviaByteSpans } = chunk;
+  if (residentByteLength == null || !Number.isSafeInteger(residentByteLength) || !Number.isSafeInteger(byteStart) || !Number.isSafeInteger(byteEnd) || byteStart < 0 || byteEnd <= byteStart || byteEnd > residentByteLength || !Number.isSafeInteger(paragraphByteStart) || !Number.isSafeInteger(paragraphByteEnd) || paragraphByteStart < byteStart || paragraphByteEnd <= paragraphByteStart || paragraphByteEnd > byteEnd || !Number.isSafeInteger(containingBodyChildOrdinal) || containingBodyChildOrdinal < 0 || bodyChildCount !== 1 || bodyChildStartOrdinal !== containingBodyChildOrdinal || bodyChildEndOrdinal !== containingBodyChildOrdinal || contentBlockCount !== 1 || contentBlockStartOrdinal == null || !Number.isSafeInteger(contentBlockStartOrdinal) || contentBlockStartOrdinal < 0 || contentBlockEndOrdinal !== contentBlockStartOrdinal || markerChildCount !== 0 || opaqueAnchorCount !== 0 || firstChildKind !== lastChildKind || firstChildKind !== "p" && firstChildKind !== "tbl" && firstChildKind !== "sdt")
+    return null;
+  let ownerByteStart = byteStart;
+  if (triviaByteSpans.length === 0) {
+    if (containsTrivia)
+      return null;
+  } else {
+    if (!containsTrivia || triviaByteSpans.length !== 1)
+      return null;
+    const [triviaStart, triviaEnd] = triviaByteSpans[0];
+    if (triviaStart !== byteStart || !Number.isSafeInteger(triviaEnd) || triviaEnd <= triviaStart || triviaEnd >= byteEnd)
+      return null;
+    ownerByteStart = triviaEnd;
+  }
+  if (paragraphByteStart < ownerByteStart)
+    return null;
+  return {
+    status: "ok",
+    bodyChildOrdinal: bodyChildStartOrdinal,
+    localName: firstChildKind,
+    byteStart: ownerByteStart,
+    byteEnd
+  };
+}
 function locateExactResidentBodyChild(state, storyId, partUri, byteStart, byteEnd, cache) {
   const chunks = findChunksContainingRange(state.sourceCoverage.get(storyId)?.chunks ?? [], partUri, byteStart, byteEnd);
   if (chunks.length === 0)
@@ -178539,14 +178667,20 @@ function locateContainingResidentBodyChild(state, storyId, partUri, paragraphByt
   const chunks = findChunksContainingRange(state.sourceCoverage.get(storyId)?.chunks ?? [], partUri, paragraphByteStart, paragraphByteEnd);
   if (chunks.length === 0)
     return { status: "failed", reason: "body-child-not-found" };
-  const bytes = state.packageBytes.get(partUri);
-  if (!bytes)
-    return { status: "failed", reason: "body-child-not-found" };
+  let bytes;
   const matches = [];
   for (const chunk of chunks) {
     const relativeOrdinal = containingBodyChildOrdinal - chunk.bodyChildStartOrdinal;
     if (relativeOrdinal < 0 || containingBodyChildOrdinal > chunk.bodyChildEndOrdinal)
       continue;
+    const singleChild = locateSingleResidentBodyChild(state, storyId, partUri, chunk, paragraphByteStart, paragraphByteEnd, containingBodyChildOrdinal);
+    if (singleChild) {
+      matches.push(singleChild);
+      continue;
+    }
+    bytes ?? (bytes = state.packageBytes.get(partUri));
+    if (!bytes)
+      return { status: "failed", reason: "body-child-not-found" };
     const chunkXml = TD24.decode(bytes.subarray(chunk.byteStart, chunk.byteEnd));
     const spans = listTopLevelElementSpans2(chunkXml);
     const span = spans[relativeOrdinal];
@@ -212431,10 +212565,16 @@ function prepareParagraphDelete(state, op) {
     return { ok: true, noOp: true, target, bytes, xml, paraXml, successor };
   }
   const structural = classifyParagraphStructural(paraXml, {
-    allowRelationshipBearing: true
+    allowRelationshipBearing: true,
+    allowInlineSdtDeletion: changeMode === "direct"
   });
   if (!structural.ok)
     return { ok: false, reason: structural.reason };
+  if (changeMode === "direct") {
+    const sdtFailure = validateDirectParagraphInlineSdtDeletion(bytes, target.entry.byteStart, paraXml);
+    if (sdtFailure)
+      return { ok: false, reason: sdtFailure };
+  }
   const namespaces = /(?:drawing|pict)/.test(paraXml) ? namespaceBindingsAtPosition(bytes, target.entry.byteStart, matchParagraphOpenTag(paraXml) ?? "") : undefined;
   const hasDrawing = namespaces && collectXmlElementRanges(paraXml, {
     fragment: true,
@@ -214170,6 +214310,30 @@ function tableOrdinalAtOrBeforeByte(catalog, byteOffset) {
   }
   return low - 1;
 }
+function validateDirectParagraphInlineSdtDeletion(bytes, paragraphStartByte, paraXml) {
+  const sdtTags = paraXml.match(/<\s*(?:[\w.-]+:)?sdt\b/g);
+  if (!sdtTags)
+    return null;
+  const namespaces = namespaceBindingsAtPosition(bytes, paragraphStartByte, matchParagraphOpenTag(paraXml) ?? "");
+  const pieces = parseParagraphInlineMap(paraXml, namespaces).pieces;
+  let sdtCount = 0;
+  for (const piece of pieces) {
+    if (piece.kind !== "container" || piece.containerKind !== "sdt")
+      continue;
+    sdtCount += 1;
+    const policy = classifySdtMutationPolicy(piece);
+    if (!policy.ok)
+      return policy.reason;
+    if (!policy.wrapperDeletable)
+      return "text-range-in-sdt";
+    const blocked = findBlockingSdtChild(piece.children);
+    if (blocked)
+      return blocked;
+  }
+  if (sdtCount !== sdtTags.length)
+    return "text-range-in-sdt";
+  return null;
+}
 function classifyParagraphStructural(paraXml, options = {}) {
   if (/<[\w.-]+:moveFrom\b/.test(paraXml) || /<[\w.-]+:moveTo\b/.test(paraXml)) {
     return { ok: false, reason: "paragraph-tracked-wrapper-unsupported" };
@@ -214177,7 +214341,7 @@ function classifyParagraphStructural(paraXml, options = {}) {
   if (!options.fieldsVerified && (/<[\w.-]+:fldChar\b/.test(paraXml) || /<[\w.-]+:instrText\b/.test(paraXml) || /<[\w.-]+:fldSimple\b/.test(paraXml))) {
     return { ok: false, reason: "paragraph-tracked-wrapper-unsupported" };
   }
-  if (/<[\w.-]+:sdt\b/.test(paraXml)) {
+  if (!options.allowInlineSdtDeletion && /<[\w.-]+:sdt\b/.test(paraXml)) {
     return { ok: false, reason: "paragraph-tracked-wrapper-unsupported" };
   }
   let relationshipBearing = false;
@@ -214964,6 +215128,7 @@ var init_compile_paragraph_ops = __esm(() => {
   init_sd_document_state();
   init_text_offset_mapping();
   init_paragraph_inline_model();
+  init_compile_edit_text_inline_plan();
   init_structural_boundary_map();
   init_paragraph_section_collapse();
   init_paragraph_delete_cell_boundary();
@@ -219917,15 +220082,31 @@ function canonicalizeCompareBodyRunXml(xml, referenceSteps) {
   let result = "";
   let cursor = 0;
   for (const token of tokens) {
-    const canonicalGap = canonicalizeWordprocessingReplayXml(xml.slice(cursor, token.start));
+    const canonicalGap = canonicalizeProofingRunGap(xml.slice(cursor, token.start));
     if (canonicalGap === null)
       return null;
     result += canonicalGap + token.xml;
     cursor = token.end;
   }
-  const canonicalTail = canonicalizeWordprocessingReplayXml(xml.slice(cursor));
+  const canonicalTail = canonicalizeProofingRunGap(xml.slice(cursor));
   return canonicalTail === null ? null : result + canonicalTail;
 }
+function canonicalizeProofingRunGap(xml) {
+  const markerRe = /<(?:[A-Za-z_][\w.-]*:)?proofErr\b(?:[^>"']|"[^"]*"|'[^']*')*\/>/g;
+  let result = "";
+  let cursor = 0;
+  for (const marker of xml.matchAll(markerRe)) {
+    const index = marker.index ?? 0;
+    const before = canonicalizeWordprocessingReplayXml(xml.slice(cursor, index));
+    const canonicalMarker = canonicalizeWordprocessingReplayXml(marker[0]);
+    if (before === null || canonicalMarker === null)
+      return null;
+    result += before + canonicalMarker;
+    cursor = index + marker[0].length;
+  }
+  const trailing = canonicalizeWordprocessingReplayXml(xml.slice(cursor));
+  return trailing === null ? null : result + trailing;
+}
 function collectProtectedReferenceTokens(xml, referenceSteps) {
   const tokens = [];
   for (let index = 0;index < referenceSteps.length; index += 1) {
@@ -220731,6 +220912,26 @@ function runComparePayloadInsertCommit(input, storyId, step2, changeMode, option
   });
   return withParagraphInsertionCatalogRefs(input, receipt2, paragraph.wordIds, storyId);
 }
+function unchangedBookmarkReferenceSteps(oldRuns, targetRuns) {
+  const oldHasMarker = /<(?:[\w.-]+:)?bookmark(?:Start|End)\b/.test(oldRuns);
+  const targetHasMarker = /<(?:[\w.-]+:)?bookmark(?:Start|End)\b/.test(targetRuns);
+  if (!oldHasMarker && !targetHasMarker)
+    return [];
+  const oldBookmark = preservedBookmarkRunTokens(oldRuns);
+  const targetBookmark = preservedBookmarkRunTokens(targetRuns);
+  if (!oldBookmark || !targetBookmark || oldBookmark.startXml !== targetBookmark.startXml || oldBookmark.endXml !== targetBookmark.endXml || oldBookmark.leadingXml !== targetBookmark.leadingXml || oldBookmark.trailingXml !== targetBookmark.trailingXml)
+    return null;
+  const startBindings = replayFragmentNamespaceBindings(oldBookmark.startXml);
+  const endBindings = replayFragmentNamespaceBindings(oldBookmark.endXml);
+  const bookmarkBindings = { ...startBindings, ...endBindings };
+  return [{
+    kind: "bookmark-start",
+    beforeXml: oldBookmark.startXml,
+    afterXml: oldBookmark.startXml,
+    beforeNamespaceBindings: bookmarkBindings,
+    afterNamespaceBindings: bookmarkBindings
+  }];
+}
 function runCompareBodyEditCommit(input, storyId, step2, changeMode, options, pushHistory, referenceSteps) {
   const { state, txId } = input;
   const partUri = storyPartUriFromStoryId2(storyId);
@@ -220748,6 +220949,14 @@ function runCompareBodyEditCommit(input, storyId, step2, changeMode, options, pu
   const pPrXml = findFirstElement(paraXml, "pPr")?.xml ?? "";
   const targetParagraphPropertiesXml = step2.targetParagraphPropertiesXml === undefined ? undefined : rewriteCanonicalWordprocessingPrefix(step2.targetParagraphPropertiesXml, paragraphWrapper.wordprocessingPrefix);
   const newRuns = rewriteCanonicalWordprocessingPrefix(step2.targetRunXml ?? renderParagraphRuns(step2.text), paragraphWrapper.wordprocessingPrefix);
+  const openEnd = paragraphWrapper.contentStart;
+  const closeStart = paraXml.lastIndexOf("</");
+  const innerXml = closeStart > openEnd ? paraXml.slice(openEnd, closeStart) : "";
+  const oldRunsRaw = stripElements(innerXml, "pPr");
+  const stableBookmarkSteps = unchangedBookmarkReferenceSteps(oldRunsRaw, newRuns);
+  if (stableBookmarkSteps === null && referenceSteps.length === 0)
+    return rejected14(txId, "unsupported-context");
+  const protectedReferenceSteps = [...referenceSteps, ...stableBookmarkSteps ?? []];
   let newParaXml;
   const createdRefs = [];
   if (changeMode === "tracked") {
@@ -220763,12 +220972,10 @@ function runCompareBodyEditCommit(input, storyId, step2, changeMode, options, pu
         storyId
       });
     }
-    const openEnd = paragraphWrapper.contentStart;
-    const closeStart = paraXml.lastIndexOf("</");
-    const innerXml = closeStart > openEnd ? paraXml.slice(openEnd, closeStart) : "";
-    const oldRunsRaw = stripElements(innerXml, "pPr");
     const oldRunsDel = oldRunsRaw.replace(/<((?:[\w.-]+:)?)t(\b[^>]*)>/g, "<$1delText$2>").replace(/<\/((?:[\w.-]+:)?)t>/g, "</$1delText>");
-    const protectedRuns = renderTrackedRunsWithProtectedReferences(oldRunsRaw, newRuns, referenceSteps, stamps, paragraphWrapper.wordprocessingPrefix);
+    const protectedRuns = renderTrackedRunsWithProtectedReferences(oldRunsRaw, newRuns, protectedReferenceSteps, stamps, paragraphWrapper.wordprocessingPrefix);
+    if (!protectedRuns && stableBookmarkSteps?.length)
+      return rejected14(txId, "unsupported-context");
     const delXml = protectedRuns?.xml ?? (oldRunsDel ? wrapTracked("del", oldRunsDel, stamps.del, "rsidDel", paragraphWrapper.wordprocessingPrefix) : "");
     const insXml = protectedRuns ? "" : newRuns ? wrapTracked("ins", newRuns, stamps.ins, "rsidR", paragraphWrapper.wordprocessingPrefix) : "";
     const trackedPPrXml = buildTrackedParagraphProperties(targetParagraphPropertiesXml, pPrXml, stamps.paragraphProperties ?? stamps.ins, paragraphWrapper.wordprocessingPrefix);
@@ -220852,6 +221059,10 @@ function runCompareBodyFormatEditCommit(input, storyId, step2, changeMode, optio
   const innerXml = closeStart > openEnd ? paraXml.slice(openEnd, closeStart) : "";
   const oldRunsRaw = stripElements(innerXml, "pPr");
   const paragraphPropertiesChanged = !equivalentParagraphProperties(targetPPrXml, pPrXml);
+  const stableBookmarkSteps = unchangedBookmarkReferenceSteps(oldRunsRaw, targetRunXml);
+  if (stableBookmarkSteps === null && referenceSteps.length === 0)
+    return rejected14(txId, "unsupported-context");
+  const protectedReferenceSteps = [...referenceSteps, ...stableBookmarkSteps ?? []];
   const baseSimpleRuns = scanSimpleRunFormatting(oldRunsRaw);
   const targetSimpleRuns = scanSimpleRunFormatting(targetRunXml);
   const paragraphPropertiesOnly = paragraphPropertiesChanged && baseSimpleRuns?.text === targetSimpleRuns?.text && computeRunSignature(targetRunXml) === computeRunSignature(oldRunsRaw);
@@ -220915,7 +221126,9 @@ function runCompareBodyFormatEditCommit(input, storyId, step2, changeMode, optio
       if (!stamps)
         return rejected14(txId, "no-author-configured");
       const oldRunsDel = oldRunsRaw.replace(/<((?:[\w.-]+:)?)t(\b[^>]*)>/g, "<$1delText$2>").replace(/<\/((?:[\w.-]+:)?)t>/g, "</$1delText>");
-      const protectedRuns = renderTrackedRunsWithProtectedReferences(oldRunsRaw, targetRunXml, referenceSteps, stamps, paragraphWrapper.wordprocessingPrefix);
+      const protectedRuns = renderTrackedRunsWithProtectedReferences(oldRunsRaw, targetRunXml, protectedReferenceSteps, stamps, paragraphWrapper.wordprocessingPrefix);
+      if (!protectedRuns && stableBookmarkSteps?.length)
+        return rejected14(txId, "unsupported-context");
       const delXml = protectedRuns?.xml ?? (oldRunsDel ? wrapTracked("del", oldRunsDel, stamps.del, "rsidDel", paragraphWrapper.wordprocessingPrefix) : "");
       const insXml = protectedRuns ? "" : targetRunXml ? wrapTracked("ins", targetRunXml, stamps.ins, "rsidR", paragraphWrapper.wordprocessingPrefix) : "";
       if (delXml || insXml) {
@@ -239364,7 +239577,7 @@ function toRoman(ordinal) {
 }
 function extractParagraphText(paraXml) {
   let out = "";
-  for (const match of paraXml.matchAll(/<[\w.-]+:t\b[^>]*>([\s\S]*?)<\/[\w.-]+:t>/g)) {
+  for (const match of paraXml.matchAll(/<[\w.-]+:t\b[^>]*?(?<!\/)>([\s\S]*?)<\/[\w.-]+:t>/g)) {
     out += decodeXmlText(match[1] ?? "");
   }
   return out;
@@ -246913,7 +247126,7 @@ function prepareHistoryReplayMutation(state, entry, direction, patchGroup) {
     ...contentControlRewrite.addedBlockIds,
     ...contentControlRewrite.contentBlockIds,
     ...contentControlRewrite.leadingBlockIds
-  ])] : collectPatchGroupTargetBlockIds(patchGroup);
+  ])] : patchGroup.source.kind === "compareApply" ? [...new Set(patchGroup.source.bodySteps.map((step2) => step2.blockId))] : collectPatchGroupTargetBlockIds(patchGroup);
   const currentBaseRevisions = {
     package: state.packageRevision,
     perPart: {}
@@ -247167,6 +247380,8 @@ function collectPatchGroupTargetBlockIds(patchGroup) {
   return [...blockIds];
 }
 function inferHistoryStorySurfaceFamily(sourceKind) {
+  if (sourceKind === "compareApply")
+    return "compareApply";
   if (sourceKind === "editText")
     return "storyText";
   if (sourceKind.startsWith("list"))
@@ -251364,7 +251579,7 @@ var init_operation_definitions2 = __esm(() => {
     },
     get_content: {
       toolName: "superdoc_get_content",
-      description: "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. " + 'Action "blocks" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. ' + 'When you need to evaluate or rewrite existing paragraphs or clauses, prefer action "blocks" with includeText:true so you can identify the correct block and then target it by nodeId. ' + 'Actions "text", "markdown", and "html" return compact strings. Actions "markdown_projection" and "html_projection" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. ' + "Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. " + 'Action "info" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. ' + 'The "blocks" action supports pagination via "offset" and "limit", filtering via "nodeTypes", and numbering projection via "reviewMode". Other actions ignore pagination and filtering parameters. ' + "This tool never modifies the document. " + "Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.",
+      description: "Read document content in various formats. Call this first in any workflow to understand document structure before making edits. " + 'Action "blocks" returns structured block data with nodeId, nodeType, textPreview, optional full text when includeText:true, formatting properties (fontFamily, fontSize, color, bold, underline, alignment), and ref handles for immediate use with superdoc_edit or superdoc_format. Paragraph-class blocks include tabCount, the number of U+0009 tabs in the complete text even if the 80-character preview trims or truncates them. If tabCount is positive, read includeText:true before editing; do not treat a preview space as proof that there is no tab. Its optional reviewMode selects final, original, or redline numbering metadata without filtering blocks. ' + 'When you need to evaluate or rewrite existing paragraphs or clauses, prefer action "blocks" with includeText:true so you can identify the correct block and then target it by nodeId. ' + 'Actions "text", "markdown", and "html" return compact strings. Actions "markdown_projection" and "html_projection" return detailed async projections with review modes, scopes, diagnostics, annotations, block maps, and optional source maps. ' + "Projection source targets use tracked coordinates and are valid only at evaluatedRevision; after any mutation, reproject before using them. Treat omitted or partially emitted annotations according to their status instead of guessing an anchor from rendered text. " + 'Action "info" returns document metadata: word count, paragraph count, page count, outline, available styles, and capability flags. ' + 'The "blocks" action supports pagination via "offset" and "limit", filtering via "nodeTypes", and numbering projection via "reviewMode". Other actions ignore pagination and filtering parameters. ' + "This tool never modifies the document. " + "Do NOT call superdoc_edit or superdoc_format without first reading blocks to get valid refs and formatting reference values.",
       inputExamples: [
         { action: "blocks" },
         { action: "blocks", includeText: true, offset: 0, limit: 20, reviewMode: "final" },
@@ -251656,7 +251871,7 @@ Complete new body.`,
     section: { toolName: "superdoc_section", description: "Page layout, margins, columns" },
     mutations: {
       toolName: "superdoc_mutations",
-      description: "All steps succeed or all fail; no partial application. " + "Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. " + "Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. " + 'Each step has an id, an op, a "where" clause for targeting ({by:"select", select:{...}, require:"first"|"exactlyOne"|"all"} or {by:"ref", ref:"..."} or {by:"block", nodeType:"paragraph", nodeId:"..."}), and "args" with operation-specific parameters. ' + 'Use {by:"block", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action "blocks" without relying on text matching. ' + 'For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:"blocks" and includeText:true, then rewrite the matching block by nodeId. ' + 'Use {by:"select"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. ' + 'For create steps, "where" targets an existing anchor block and args.position ("before" or "after") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. ' + 'For format.apply with require "all", use a node selector to format every heading or paragraph at once: {by:"select", select:{type:"node", nodeType:"heading"}, require:"all"}. ' + "Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. " + 'Action "preview" dry-runs the plan. Action "apply" executes it. ' + "If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. " + "Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.",
+      description: "All steps succeed or all fail; no partial application. " + "Execute multiple operations atomically in one batch. Use this for any workflow needing 2+ changes. " + "Supported step types: text (text.rewrite, text.insert, text.delete), format (format.apply), create (create.heading, create.paragraph, create.table), assert. " + 'Each step has an id, an op, a "where" clause for targeting ({by:"select", select:{...}, require:"first"|"exactlyOne"|"all"} or {by:"ref", ref:"..."} or {by:"block", nodeType:"paragraph", nodeId:"..."}), and "args" with operation-specific parameters. ' + 'Use {by:"block", nodeType, nodeId} when you want to rewrite, delete, format, or anchor against a whole known block from superdoc_get_content action "blocks" without relying on text matching. ' + 'For full-paragraph or full-clause rewrites, first call superdoc_get_content with action:"blocks" and includeText:true, then rewrite the matching block by nodeId. ' + 'For a placeholder or name within a tab-separated paragraph, use a text.rewrite where.by:"select" targeting only the exact placeholder; a whole-block plain-text rewrite omitting tabs deletes those controls. ' + 'Use {by:"select"} only for substring edits, discovery, or insertion relative to a sentence fragment; do NOT use a shortened text selector to replace an entire known block. ' + 'For create steps, "where" targets an existing anchor block and args.position ("before" or "after") controls placement. Sequential creates targeting the same anchor maintain correct order via internal position mapping. ' + 'For format.apply with require "all", use a node selector to format every heading or paragraph at once: {by:"select", select:{type:"node", nodeType:"heading"}, require:"all"}. ' + "Selectors resolve at compile time (before execution). This means format.apply steps CANNOT target content created by earlier create steps in the same batch. Split creates and formatting into separate batches: first a mutations call with creates, then a mutations call with format.apply. " + 'Action "preview" dry-runs the plan. Action "apply" executes it. ' + "If a selector matches nothing, the failure reports the step id plus selector details so you can retry with a shorter or more distinctive anchor. " + "Do NOT create two steps that target overlapping text in the same block; combine them into a single text.rewrite step.",
       inputExamples: [
         {
           action: "apply",
@@ -262080,6 +262295,11 @@ var init_schemas5 = __esm(() => {
               oneOf: [{ type: "string" }, { type: "null" }],
               description: "Full flattened block text when requested with includeText."
             },
+            tabCount: {
+              type: "integer",
+              minimum: 0,
+              description: "Tabs in complete paragraph text, even beyond the preview."
+            },
             isEmpty: { type: "boolean" },
             styleId: { oneOf: [{ type: "string" }, { type: "null" }], description: "Named paragraph style." },
             fontFamily: { type: "string", description: "Font family from first text run." },
@@ -280493,12 +280713,12 @@ function wrapRangeWithMarkupInParagraphXml(input) {
     const middleText = run.text.slice(sliceStart, sliceEnd);
     const afterText = run.text.slice(sliceEnd);
     if (beforeText.length > 0)
-      beforeSegment.push(renderRun(run.kind, run.prefix, beforeText, run.rPr, run.leafXml));
+      beforeSegment.push(renderRun(run.kind, run.prefix, beforeText, run.rPr, run.leafXml, run.open));
     if (middleText.length > 0) {
-      wrappedRuns.push(renderRun(run.kind, run.prefix, middleText, run.rPr, run.leafXml));
+      wrappedRuns.push(renderRun(run.kind, run.prefix, middleText, run.rPr, run.leafXml, run.open));
     }
     if (afterText.length > 0)
-      afterSegment.push(renderRun(run.kind, run.prefix, afterText, run.rPr, run.leafXml));
+      afterSegment.push(renderRun(run.kind, run.prefix, afterText, run.rPr, run.leafXml, run.open));
     segmentCursor = run.xmlEnd;
   }
   if (wrappedRuns.length === 0) {
@@ -280528,6 +280748,8 @@ function replaceRangeInParagraphXml(input) {
       const gapXml = input.paragraphXml.slice(segmentCursor, run.xmlStart);
       if (index === span.value.firstRunIdx)
         beforeSegment.push(gapXml);
+      else if (gapXml.trim())
+        return { ok: false, reason: "unsupported-context" };
     }
     const sliceStart = index === span.value.firstRunIdx ? span.value.startInFirstRun : 0;
     const sliceEnd = index === span.value.lastRunIdx ? span.value.endInLastRun : run.text.length;
@@ -280998,6 +281220,7 @@ function parsePlainRun2(runXml, textStart, xmlStart, xmlEnd) {
       xmlStart,
       xmlEnd,
       xml: runXml,
+      open: run.open,
       prefix: run.prefix,
       textStart,
       textEnd: textStart + text.length,
@@ -281334,15 +281557,15 @@ function buildRPrChange(prefix, stamp, previousChildren) {
   const previous = `<${prefix}:rPr>${serializeTopLevelChildren(previousChildren)}</${prefix}:rPr>`;
   return `<${prefix}:rPrChange w:id="${stamp.revisionId}" w:author="${escapeXmlAttribute3(stamp.author.name)}"${initials} w:date="${escapeXmlAttribute3(stamp.date)}">${previous}</${prefix}:rPrChange>`;
 }
-function renderRun(kind, prefix, text, rPrXml, leafXml) {
+function renderRun(kind, prefix, text, rPrXml, leafXml, runOpen = `<${prefix}:r>`) {
   if (kind !== "text") {
     if (text.length === 0)
       return "";
     const fallbackLeaf = kind === "tab" ? `<${prefix}:tab/>` : `<${prefix}:${kind}/>`;
-    return `<${prefix}:r>${rPrXml}${leafXml ?? fallbackLeaf}</${prefix}:r>`;
+    return `${runOpen}${rPrXml}${leafXml ?? fallbackLeaf}</${prefix}:r>`;
   }
   const preserve = /^\s|\s$/.test(text) ? ' xml:space="preserve"' : "";
-  return `<${prefix}:r>${rPrXml}<${prefix}:t${preserve}>${escapeXmlText3(text)}</${prefix}:t></${prefix}:r>`;
+  return `${runOpen}${rPrXml}<${prefix}:t${preserve}>${escapeXmlText3(text)}</${prefix}:t></${prefix}:r>`;
 }
 function ensureHyperlinkRunStyle2(rPrXml, fallbackPrefix, styleId = "Hyperlink") {
   const escapedStyleId = escapeXmlAttribute3(styleId);
@@ -285282,6 +285505,9 @@ function createParagraphIdBatchAllocator(context, count) {
 function collectPackageParaIds(context) {
   const used = new Set;
   for (const partUri of listSDDocumentSessionInternalPartUris(context.session)) {
+    const contentType = getSDDocumentSessionInternalPartDescriptor(context.session, partUri)?.contentType?.toLowerCase();
+    if (!partUri.toLowerCase().endsWith(".xml") && !contentType?.endsWith("+xml") && contentType !== "application/xml")
+      continue;
     const bytes = getSDDocumentSessionInternalPartBytes(context.session, partUri);
     if (!bytes)
       continue;
@@ -302565,11 +302791,16 @@ function projectTableListEntry(ordinal, nodeId, text, includeText) {
 }
 function projectParagraphListEntry(input) {
   const trimmed = input.text.trim();
+  let tabCount = 0;
+  for (let position = input.text.indexOf("\t");position !== -1; position = input.text.indexOf("\t", position + 1)) {
+    tabCount++;
+  }
   const item = {
     ordinal: input.ordinal,
     nodeId: input.nodeId,
     nodeType: input.nodeType,
     textPreview: trimmed.length > 80 ? `${trimmed.slice(0, 77)}…` : trimmed,
+    tabCount,
     isEmpty: trimmed.length === 0
   };
   if (input.styleId)
@@ -328985,7 +329216,7 @@ class V2ContentControlsAdapter {
   }
   setTextValue(input, options) {
     const loaded = this.load();
-    const control = this.requireBodyControl(input.target, loaded);
+    const control = options?.changeMode === "tracked" ? this.requireBodyControl(input.target, loaded) : this.requireControl(input.target, loaded);
     if (control.info.controlType !== "text") {
       throw operationError("TYPE_MISMATCH", `contentControls.text.setValue requires control type text, but found "${control.info.controlType}".`);
     }
@@ -329005,9 +329236,14 @@ class V2ContentControlsAdapter {
     }
     if (dryRunRequested(input, options))
       return this.validateDryRun(input, options, control.target);
+    const part = loaded.parts.find((candidate2) => candidate2.storyId === control.storyId);
     const replacement = replaceSdtContentXml(control, buildTextReplacementContentXml(value2, control.info.kind, createParaIdAllocator(this.context), control.contentXml, false));
-    const nextXml = replaceRange2(loaded.documentXml, control.start, control.end, replacement);
-    return this.commitDocument(nextXml, "content-control-replace-content", input, options, control.target);
+    const nextXml = replaceRange2(part.xml, control.start, control.end, replacement);
+    return this.commitDocument(nextXml, "content-control-replace-content", input, options, control.target, {
+      partUri: part.partUri,
+      storySurface: { family: "storyBlocks", contentControlRewrite: true, targetBlockIds: [] },
+      preserveRenderCommit: this.context.isCollaborativeSession()
+    });
   }
   setDateValue(input, options) {
     const loaded = this.load();
@@ -329228,12 +329464,14 @@ class V2ContentControlsAdapter {
   }
   mutateControl(target, input, options, transform2, prefix = "content-control-mutate", validate) {
     const loaded = this.load();
-    const control = this.requireBodyControl(target, loaded);
-    validate?.(control, loaded);
     const tracked = options?.changeMode === "tracked";
+    const storyAware = prefix === "content-control-pr" || prefix === "content-control-unwrap";
+    const control = tracked || !storyAware ? this.requireBodyControl(target, loaded) : this.requireControl(target, loaded);
+    const part = loaded.parts.find((candidate2) => candidate2.storyId === control.storyId);
+    validate?.(control, loaded);
     if (tracked) {
       this.validateTrackedControlMutation(input, options);
-      if (hasTrackedControlAncestor(loaded.documentXml, control) || !["content-control-delete", "content-control-unwrap", "content-control-repeat-delete", "content-control-pr"].includes(prefix)) {
+      if (hasTrackedControlAncestor(part.xml, control) || !["content-control-delete", "content-control-unwrap", "content-control-repeat-delete", "content-control-pr"].includes(prefix)) {
         this.requireDirectControlStructure(input, options);
       }
     }
@@ -329246,12 +329484,12 @@ class V2ContentControlsAdapter {
     let replacement = typeof transformed === "string" ? transformed : transformed.xml;
     let createdRefs = typeof transformed === "string" ? undefined : transformed.createdRefs;
     if (tracked && typeof transformed === "string") {
-      const namespaces = collectXmlElementRanges(loaded.documentXml).ranges.find((range) => range.start === control.start)?.namespaceBindings;
+      const namespaces = collectXmlElementRanges(part.xml).ranges.find((range) => range.start === control.start)?.namespaceBindings;
       const prepared = prepareTrackedContentControlXml({
         context: this.context,
         beforeXml: control.xml,
         afterXml: replacement,
-        kind: trackedControlPlacement(loaded.documentXml, control),
+        kind: trackedControlPlacement(part.xml, control),
         ownership: prefix === "content-control-unwrap" || prefix === "content-control-repeat-delete",
         namespaceBindings: new Map(Object.entries(namespaces ?? {})),
         expectedRevision: expectedRevisionFrom(input, options),
@@ -329262,8 +329500,13 @@ class V2ContentControlsAdapter {
       replacement = prepared.xml;
       createdRefs = prepared.wordIds.map((entityId) => ({ kind: "trackedChange", entityId, storyId: control.storyId }));
     }
-    const nextXml = replaceRange2(loaded.documentXml, control.start, control.end, replacement);
-    return this.commitDocument(nextXml, prefix, input, options, control.target, { createdRefs });
+    const nextXml = replaceRange2(part.xml, control.start, control.end, replacement);
+    return this.commitDocument(nextXml, prefix, input, options, control.target, {
+      partUri: part.partUri,
+      storySurface: { family: "storyBlocks", contentControlRewrite: true, targetBlockIds: [] },
+      preserveRenderCommit: this.context.isCollaborativeSession(),
+      createdRefs
+    });
   }
   insertRepeatingItem(input, options, insertIndex) {
     this.validateTrackedControlMutation(input, options);
@@ -331068,7 +331311,7 @@ function wrapSelectionInXml(context, documentXml, target, sdtXml, kind, replacem
       }
     };
   }
-  if (kind === "inline" && !hasReplacementContent && selectedTextRunCount(para.xml, target.start.offset, target.end.offset) > 1) {
+  if (kind === "inline" && !hasReplacementContent) {
     const template = splitSdtTemplateAroundContent(sdtXml);
     if (!template) {
       return {
@@ -331089,6 +331332,18 @@ function wrapSelectionInXml(context, documentXml, target, sdtXml, kind, replacem
     if (wrappedRuns.ok) {
       return { ok: true, xml: replaceRange2(documentXml, para.start, para.end, wrappedRuns.xml) };
     }
+    return { ok: false, failure: { code: "CAPABILITY_UNAVAILABLE", message: "Content-control selection spans unsupported inline structures." } };
+  }
+  if (kind === "inline" && hasReplacementContent) {
+    const replaced = replaceRangeInParagraphXml({
+      paragraphXml: para.xml,
+      rangeStart: target.start.offset,
+      rangeEnd: target.end.offset,
+      replacementXml: replaceSdtContentInTemplate(sdtXml, buildReplacementContentXml2(replacementContent))
+    });
+    if (replaced.ok) {
+      return { ok: true, xml: replaceRange2(documentXml, para.start, para.end, replaced.xml) };
+    }
     return {
       ok: false,
       failure: {
@@ -331105,15 +331360,6 @@ function wrapSelectionInXml(context, documentXml, target, sdtXml, kind, replacem
     return { ok: false, failure: { code: "CAPABILITY_UNAVAILABLE", message: "Content-control selection spans unsupported inline structures." } };
   return { ok: true, xml: replaceRange2(documentXml, para.start, para.end, wrapped) };
 }
-function selectedTextRunCount(paragraphXml, start, end) {
-  const runs = new Set;
-  for (const piece of parseParagraphInlineMap(paragraphXml).leaves()) {
-    if (piece.kind === "text" && piece.textRole === "visible" && piece.visibleStart < end && piece.visibleEnd > start) {
-      runs.add(piece.runCharStart);
-    }
-  }
-  return runs.size;
-}
 function splitSdtTemplateAroundContent(sdtXml) {
   const sdtRange = findFirstSdtElementRange(sdtXml);
   if (!sdtRange)
@@ -393765,6 +394011,7 @@ function createHocuspocusSingleDocAdapter(config2) {
           token: typeof config2.token === "string" || config2.token == null ? config2.token ?? null : config2.token,
           parameters: config2.params ?? {},
           preserveConnection: false,
+          broadcast: config2.broadcast ?? true,
           quiet: true,
           onSynced() {
             if (!hasSynced) {
@@ -407312,7 +407559,7 @@ function parseRun2(runXml, textTagLocalName = "t", inheritedNamespaceBindings =
         atomKind: INLINE_ATOM_KIND.noteRef,
         id: attrLocal2(next.openTagInner, "id"),
         xml: next.xml,
-        meta: { kind: local },
+        meta: { kind: local, runAttributes: attributes },
         visibleLength: 0
       });
     } else if (local === "sym" || local === "noBreakHyphen") {
@@ -407323,7 +407570,7 @@ function parseRun2(runXml, textTagLocalName = "t", inheritedNamespaceBindings =
         atomKind: INLINE_ATOM_KIND.preserved,
         id: null,
         xml: next.xml,
-        meta: { tag: local, container: "run-child" },
+        meta: { tag: local, container: "run-child", runAttributes: attributes },
         visibleLength: 0
       });
     }
@@ -420555,7 +420802,9 @@ function serializeBlockXml(block, extraAtoms = [], context = { inherited: CANONI
       const atomXml = atom.kind === "synthetic-comment-marker" ? `<${w}:${atom.meta.marker} ${w}:id="${xmlEscape(String(atom.meta.commentId))}"/>` : atom.xml;
       const attributedBreakXml = runBackedAttributedBreakXml(atom);
       if (atomEmissionMode(atom) === "run-child") {
-        sb.push(serializeInlineRunAtom(attributedBreakXml ?? atomXml, runAttributes, w));
+        const atomRunAttributes = atom.meta.runAttributes;
+        const attributes = atomRunAttributes && typeof atomRunAttributes === "object" && !Array.isArray(atomRunAttributes) ? atomRunAttributes : runAttributes;
+        sb.push(serializeInlineRunAtom(attributedBreakXml ?? atomXml, attributes, w));
       } else {
         sb.push(atomXml);
       }
@@ -424846,7 +425095,7 @@ function hasStrictMirrorPrerequisites(prepared, options) {
     case "storyAnchor":
       return options.session != null;
     case "compareApply":
-      return false;
+      return options.session != null;
     default: {
       const exhaustive = extension2.family;
       return exhaustive;
@@ -424944,13 +425193,24 @@ function runFamilyMirror(prepared, extension2, options, directStoryText, tracked
     return mirrorPreparedTrackedDecide(prepared, trackedDecision);
   }
   if (extension2.family === "compareApply") {
-    return {
-      mirrored: false,
-      failure: {
-        storyId: prepared.resolvedTargets.stories[0] ?? "",
-        message: "story-surface mirror for the compareApply family is not supported (apply-deferred)"
-      }
-    };
+    if (!options.session) {
+      return {
+        mirrored: false,
+        mirrorPath: "session-sync",
+        failure: {
+          storyId: prepared.resolvedTargets.stories[0] ?? "",
+          message: "compareApply session sync requires an authoritative session"
+        }
+      };
+    }
+    const sessionSync = mirrorStorySurfaceFromSession({
+      session: options.session,
+      prepared,
+      extension: extension2,
+      storyIds: storyIdsRequiringShards(prepared, extension2),
+      resolveStoryShard: options.resolveStoryShard
+    });
+    return { ...sessionSync, mirrorPath: "session-sync" };
   }
   if (extension2.family === "storyAnchor" && prepared.source.kind === "insertComment" && !prepared.source.materialize) {
     return mirrorPreparedCommentInsert(prepared, extension2, options);
@@ -425718,6 +425978,9 @@ function admitPreparedStorySurfaceMutation(prepared, options) {
   }
   if (!touchesOwnedStoryPart(prepared))
     return { ok: true };
+  if (extension2.family === "compareApply") {
+    return validateCompareApplySessionSync(prepared, extension2, options);
+  }
   if (extension2.family === "storyText") {
     if (extension2.historyReplay || extension2.resyncFromSession || extension2.sessionSync) {
       return validateStoryTextSessionSync(prepared, extension2, options);
@@ -425786,6 +426049,32 @@ function admitPreparedStorySurfaceMutation(prepared, options) {
   }
   return { ok: true };
 }
+function validateCompareApplySessionSync(prepared, extension2, options) {
+  const source = prepared.source;
+  if (source.kind !== "compareApply" || !options.session) {
+    return { ok: false, message: "compareApply session sync requires an authoritative session" };
+  }
+  if (options.isSessionProjectionCurrent?.() !== true) {
+    return { ok: false, message: "compareApply requires a current collaborative session projection" };
+  }
+  const storyId = String(source.storyId);
+  const ownership = prepared.resolvedTargets.storyPartOwnership;
+  if (!extension2.storyLocal || prepared.resolvedTargets.stories.length !== 1 || String(prepared.resolvedTargets.stories[0]) !== storyId || ownership.length !== 1 || String(ownership[0]?.storyId) !== storyId || prepared.resolvedTargets.partUris.length !== 1 || String(prepared.resolvedTargets.partUris[0]) !== String(ownership[0]?.partUri)) {
+    return { ok: false, message: "compareApply collaboration requires one owned story part" };
+  }
+  if (source.bodySteps.length === 0 || source.bodySteps.some((step3) => step3.kind !== "edit") || source.storyGroups?.length || source.storyPackageOperations?.length || source.commentSteps?.length || source.packageRewrites?.length || source.relationshipBackedBodyRewrites?.length || source.headerFooterLifecycle || source.headerFooterSlotSteps?.length || source.tableTopologySteps?.length || source.tableBlockSteps?.length || source.tablePropertySteps?.length || source.sectionReplaySteps?.length || source.referenceReplaySteps?.length) {
+    return { ok: false, message: "compareApply collaboration supports paragraph text edits only" };
+  }
+  const targetBlockIds2 = [...new Set(source.bodySteps.map((step3) => step3.blockId))];
+  if (targetBlockIds2.length !== extension2.targetBlockIds.length || targetBlockIds2.some((blockId) => !extension2.targetBlockIds.includes(blockId))) {
+    return { ok: false, message: "compareApply target blocks do not match its prepared refresh scope" };
+  }
+  const shard = options.resolveStoryShard(storyId);
+  if (!shard || targetBlockIds2.some((blockId) => !findBlockMap(shard, blockId))) {
+    return { ok: false, message: "compareApply target blocks are missing from the story shard" };
+  }
+  return { ok: true };
+}
 function validateStoryTextSessionSync(prepared, extension2, options) {
   if (!options.session) {
     return { ok: false, message: "storyText session sync requires an authoritative session" };
@@ -427422,6 +427711,7 @@ function createCollabV2SessionProjectionController(options) {
   const storyBackend = createStorySurfaceExecutionBackend({
     delegate: packageBackend,
     session: options.session,
+    isSessionProjectionCurrent: () => !destroyed && !remoteProjectionPending && !deferredSessionAuthoritativeRemotePending && sessionStoryAlignment === "aligned",
     resolveStoryShard(storyId) {
       const handle = options.dispatcherRegistry.findStoryShardByStoryId?.(storyId);
       return handle ? collabUnitTargetOrDoc(handle) : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc/mcp",
-  "version": "1.2.0-next.1",
+  "version": "1.2.0-next.10",
   "description": "Model Context Protocol server for SuperDoc, giving an AI agent tools to read and edit .docx files.",
   "type": "module",
   "license": "AGPL-3.0",
@@ -24,13 +24,13 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "@superdoc/sdk": "2.15.0-next.1",
+    "@superdoc/sdk": "2.15.0-next.10",
     "debug": "^4.4.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "superdoc": "2.18.0-next.1",
-    "@superdoc/docx-engine": "0.17.0-next.1",
+    "superdoc": "2.18.0-next.10",
+    "@superdoc/docx-engine": "0.17.0-next.12",
     "@superdoc/document-api": "0.1.0-alpha.0",
     "@types/bun": "^1.3.8",
     "@types/node": "22.19.2",