@kimdayoun/hwpx-mcp 0.3.4 → 0.3.5

package/dist/index.js

@@ -42,6 +42,7 @@ const path = __importStar(require("path"));
 const HwpxDocument_1 = require("./HwpxDocument");
 const HangingIndentCalculator_1 = require("./HangingIndentCalculator");
 const XmlWellFormed_1 = require("./XmlWellFormed");
+const ToolResult_1 = require("./ToolResult");
 const MCP_VERSION = require('../package.json').version;
 console.error(`[HWPX MCP] Server starting - ${MCP_VERSION} - ${new Date().toISOString()}`);
 // Document storage
@@ -277,7 +278,7 @@ Example workflow for templates:
 3. Save - all original formatting preserved
 
 ⚠️ If you need to CHANGE alignment/style, use set_paragraph_style instead.
-⚠️ For paragraphs with multiple styled runs (bold + normal), use update_paragraph_text_preserve_styles.`,
+⚠️ With run_index 0 (default) the whole paragraph is replaced: the new text takes the FIRST run's character shape and the other runs are emptied. To keep a bold/plain split, use update_paragraph_text_preserve_styles.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -2155,17 +2156,8 @@ const requiredArgsByTool = new Map(tools.map(tool => [
     tool.name,
     (tool.inputSchema?.required) ?? [],
 ]));
-/**
- * Report the exact missing arguments instead of letting the handler fail with a
- * generic message. `section_index` is declared required on the insert/update
- * tools, but omitting it used to surface as "Failed to insert paragraph", which
- * reads like document corruption and sends callers off inspecting the file.
- */
 function findMissingArgs(toolName, args) {
-    const required = requiredArgsByTool.get(toolName);
-    if (!required || required.length === 0)
-        return [];
-    return required.filter(key => args?.[key] === undefined || args?.[key] === null);
+    return (0, ToolResult_1.findMissingArgs)(requiredArgsByTool, toolName, args);
 }
 // ============================================================
 // Tool Handlers
@@ -2174,7 +2166,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const missing = findMissingArgs(name, args);
     if (missing.length > 0) {
-        return error(`Missing required argument${missing.length > 1 ? 's' : ''} for ${name}: ${missing.join(', ')}`);
+        return (0, ToolResult_1.error)(`Missing required argument${missing.length > 1 ? 's' : ''} for ${name}: ${missing.join(', ')}`);
     }
     try {
         switch (name) {
@@ -2330,21 +2322,21 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 const known = Object.keys(guides);
                 const guide = guides[workflow];
                 if (!guide) {
-                    return error(`Unknown workflow "${workflow}". Available: ${known.join(', ')}`);
+                    return (0, ToolResult_1.error)(`Unknown workflow "${workflow}". Available: ${known.join(', ')}`);
                 }
-                return success({ workflow, available_workflows: known, guide });
+                return (0, ToolResult_1.success)({ workflow, available_workflows: known, guide });
             }
             // === Document Management ===
             case 'open_document': {
                 const filePath = args?.file_path;
                 if (!filePath)
-                    return error('file_path is required');
+                    return (0, ToolResult_1.error)('file_path is required');
                 const absolutePath = path.resolve(filePath);
                 const data = fs.readFileSync(absolutePath);
                 const docId = generateId();
                 const doc = await HwpxDocument_1.HwpxDocument.createFromBuffer(docId, absolutePath, data);
                 openDocuments.set(docId, doc);
-                return success({
+                return (0, ToolResult_1.success)({
                     doc_id: docId,
                     format: doc.format,
                     path: absolutePath,
@@ -2355,17 +2347,17 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'close_document': {
                 const docId = args?.doc_id;
                 if (openDocuments.delete(docId)) {
-                    return success({ message: 'Document closed' });
+                    return (0, ToolResult_1.success)({ message: 'Document closed' });
                 }
-                return error('Document not found');
+                return (0, ToolResult_1.error)('Document not found');
             }
             case 'save_document': {
                 const docId = args?.doc_id;
                 const doc = getDoc(docId);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 // Use document lock to ensure all pending updates complete before save
                 return await withDocumentLock(docId, async () => {
                     // `file_path` is the parameter name used by open_document/create_document,
@@ -2373,7 +2365,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     // falling back to the document's own path.
                     const requestedPath = args?.output_path || args?.file_path;
                     if (!requestedPath && !doc.hasPath) {
-                        return error('output_path is required for a document created with create_document; ' +
+                        return (0, ToolResult_1.error)('output_path is required for a document created with create_document; ' +
                             'it has no location on disk yet');
                     }
                     const savePath = path.resolve(requestedPath || doc.path);
@@ -2382,7 +2374,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     let backupPath = null;
                     const saveDirectory = path.dirname(savePath);
                     if (!fs.existsSync(saveDirectory)) {
-                        return error(`Directory does not exist: ${saveDirectory}`);
+                        return (0, ToolResult_1.error)(`Directory does not exist: ${saveDirectory}`);
                     }
                     // A private directory prevents pre-created .tmp symlinks from redirecting writes.
                     const tempDirectory = fs.mkdtempSync(path.join(saveDirectory, '.hwpx-save-'));
@@ -2392,7 +2384,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                             backupPath = savePath + '.bak';
                             const existingBackup = fs.lstatSync(backupPath, { throwIfNoEntry: false });
                             if (existingBackup && !existingBackup.isFile()) {
-                                return error('Backup destination must be a regular file');
+                                return (0, ToolResult_1.error)('Backup destination must be a regular file');
                             }
                             const stagedBackup = path.join(tempDirectory, 'backup.hwpx');
                             fs.copyFileSync(savePath, stagedBackup, fs.constants.COPYFILE_EXCL);
@@ -2440,15 +2432,15 @@ Call get_tool_guide with: template, table, image, search, read, create`
                                 }
                                 // Restore from backup if exists
                                 if (backupPath && fs.existsSync(backupPath)) {
-                                    return error(`Save verification failed, backup preserved: ${verifyErr}`);
+                                    return (0, ToolResult_1.error)(`Save verification failed, backup preserved: ${verifyErr}`);
                                 }
-                                return error(`Save verification failed: ${verifyErr}`);
+                                return (0, ToolResult_1.error)(`Save verification failed: ${verifyErr}`);
                             }
                         }
                         // Do not unlink first: a failed rename must leave the original document intact.
                         fs.renameSync(tempPath, savePath);
                         doc.setPath(savePath);
-                        return success({
+                        return (0, ToolResult_1.success)({
                             message: `Saved to ${savePath}`,
                             path: savePath,
                             backup_created: backupPath ? true : false,
@@ -2457,7 +2449,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                         });
                     }
                     catch (saveErr) {
-                        return error(`Save failed; original document preserved: ${saveErr}`);
+                        return (0, ToolResult_1.error)(`Save failed; original document preserved: ${saveErr}`);
                     }
                     finally {
                         fs.rmSync(tempDirectory, { recursive: true, force: true });
@@ -2471,33 +2463,33 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     format: d.format,
                     isDirty: d.isDirty,
                 }));
-                return success({ documents: docs });
+                return (0, ToolResult_1.success)({ documents: docs });
             }
             // === Document Info ===
             case 'get_document_text': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ text: doc.getAllText() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ text: doc.getAllText() });
             }
             case 'get_document_structure': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success(doc.getStructure());
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)(doc.getStructure());
             }
             case 'get_document_metadata': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ metadata: doc.getMetadata() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ metadata: doc.getMetadata() });
             }
             case 'set_document_metadata': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const metadata = {};
                 if (args?.title)
                     metadata.title = args.title;
@@ -2508,36 +2500,36 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 if (args?.description)
                     metadata.description = args.description;
                 doc.setMetadata(metadata);
-                return success({ metadata: doc.getMetadata() });
+                return (0, ToolResult_1.success)({ metadata: doc.getMetadata() });
             }
             // === Paragraph Operations ===
             case 'get_paragraphs': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const sectionIndex = args?.section_index;
                 const paragraphs = doc.getParagraphs(sectionIndex);
-                return success({ paragraphs });
+                return (0, ToolResult_1.success)({ paragraphs });
             }
             case 'get_paragraph': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const result = doc.getParagraph(args?.section_index, args?.paragraph_index);
                 if (!result)
-                    return error('Paragraph not found');
-                return success(result);
+                    return (0, ToolResult_1.error)('Paragraph not found');
+                return (0, ToolResult_1.success)(result);
             }
             case 'insert_paragraph': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const sectionIndex = args?.section_index;
                 const index = doc.insertParagraph(sectionIndex, args?.after_index, args?.text);
                 if (index === -1)
-                    return error('Failed to insert paragraph');
+                    return (0, ToolResult_1.error)('Failed to insert paragraph');
                 // Auto hanging indent (default: true)
                 const autoHangingIndent = args?.auto_hanging_indent !== false;
                 let indentPt = 0;
@@ -2546,68 +2538,68 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     indentPt = await doc.setAutoHangingIndentAsync(sectionIndex, index, 10);
                 }
                 if (indentPt > 0) {
-                    return success({ message: `Paragraph inserted with hanging indent: ${indentPt.toFixed(2)}pt`, index, indent_pt: indentPt });
+                    return (0, ToolResult_1.success)({ message: `Paragraph inserted with hanging indent: ${indentPt.toFixed(2)}pt`, index, indent_pt: indentPt });
                 }
-                return success({ message: 'Paragraph inserted', index });
+                return (0, ToolResult_1.success)({ message: 'Paragraph inserted', index });
             }
             case 'delete_paragraph': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.deleteParagraph(args?.section_index, args?.paragraph_index)) {
-                    return success({ message: 'Paragraph deleted' });
+                    return (0, ToolResult_1.success)({ message: 'Paragraph deleted' });
                 }
-                return error('Failed to delete paragraph');
+                return (0, ToolResult_1.error)('Failed to delete paragraph');
             }
             case 'update_paragraph_text': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
-                const sectionIndex = args?.section_index;
-                const paragraphIndex = args?.paragraph_index;
-                const text = args?.text;
-                // Auto-use preserve styles method for multi-run paragraphs
-                const para = doc.getParagraph(sectionIndex, paragraphIndex);
-                if (para && para.runs && para.runs.length > 1) {
-                    doc.updateParagraphTextPreserveStyles(sectionIndex, paragraphIndex, text);
-                }
-                else {
-                    doc.updateParagraphText(sectionIndex, paragraphIndex, args?.run_index ?? 0, text);
-                }
-                return success({ message: 'Paragraph updated' });
+                    return (0, ToolResult_1.error)('HWP files are read-only');
+                // Always replace through updateParagraphText. Replacing run 0 means
+                // "replace the whole paragraph": the text goes into the first run and
+                // the other runs are emptied, so it takes the first run's character
+                // shape. This handler used to send any multi-run paragraph to
+                // updateParagraphTextPreserveStyles, which spreads the new text across
+                // the old runs by length — a paragraph with a plain run and a bold run,
+                // replaced wholesale, came out bold from the middle on (reported
+                // 2026-09-24, and still true in 0.3.4 because the fix only reached
+                // updateParagraphText). Keeping each run's style is what
+                // update_paragraph_text_preserve_styles is for.
+                doc.updateParagraphText(args?.section_index, args?.paragraph_index, args?.run_index ?? 0, args?.text);
+                return (0, ToolResult_1.success)({ message: 'Paragraph updated' });
             }
             case 'update_paragraph_text_preserve_styles': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.updateParagraphTextPreserveStyles(args?.section_index, args?.paragraph_index, args?.text);
                 if (result) {
-                    return success({ message: 'Paragraph text updated with preserved styles' });
+                    return (0, ToolResult_1.success)({ message: 'Paragraph text updated with preserved styles' });
                 }
-                return error('Failed to update paragraph (not found or no runs)');
+                return (0, ToolResult_1.error)('Failed to update paragraph (not found or no runs)');
             }
             case 'append_text_to_paragraph': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 doc.appendTextToParagraph(args?.section_index, args?.paragraph_index, args?.text);
-                return success({ message: 'Text appended' });
+                return (0, ToolResult_1.success)({ message: 'Text appended' });
             }
             // === Character Styling ===
             case 'set_text_style': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const style = {};
                 if (args?.bold !== undefined)
                     style.bold = args.bold;
@@ -2626,22 +2618,22 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 if (args?.background_color)
                     style.backgroundColor = args.background_color;
                 doc.applyCharacterStyle(args?.section_index, args?.paragraph_index, args?.run_index ?? 0, style);
-                return success({ message: 'Text style applied' });
+                return (0, ToolResult_1.success)({ message: 'Text style applied' });
             }
             case 'get_text_style': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const style = doc.getCharacterStyle(args?.section_index, args?.paragraph_index, args?.run_index);
-                return success({ style });
+                return (0, ToolResult_1.success)({ style });
             }
             // === Paragraph Styling ===
             case 'set_paragraph_style': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const style = {};
                 if (args?.align)
                     style.align = args.align;
@@ -2658,85 +2650,85 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 if (args?.first_line_indent)
                     style.firstLineIndent = args.first_line_indent;
                 doc.applyParagraphStyle(args?.section_index, args?.paragraph_index, style);
-                return success({ message: 'Paragraph style applied' });
+                return (0, ToolResult_1.success)({ message: 'Paragraph style applied' });
             }
             case 'get_paragraph_style': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const style = doc.getParagraphStyle(args?.section_index, args?.paragraph_index);
-                return success({ style });
+                return (0, ToolResult_1.success)({ style });
             }
             // === Hanging Indent (내어쓰기) ===
             case 'set_hanging_indent': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.setHangingIndent(args?.section_index, args?.paragraph_index, args?.indent_pt);
                 if (!result)
-                    return error('Failed to set hanging indent. Check section/paragraph indices and indent value (must be positive).');
-                return success({ message: `Hanging indent set to ${args?.indent_pt}pt` });
+                    return (0, ToolResult_1.error)('Failed to set hanging indent. Check section/paragraph indices and indent value (must be positive).');
+                return (0, ToolResult_1.success)({ message: `Hanging indent set to ${args?.indent_pt}pt` });
             }
             case 'get_hanging_indent': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const indent = doc.getHangingIndent(args?.section_index, args?.paragraph_index);
                 if (indent === null)
-                    return error('Invalid section or paragraph index');
-                return success({ hanging_indent_pt: indent });
+                    return (0, ToolResult_1.error)('Invalid section or paragraph index');
+                return (0, ToolResult_1.success)({ hanging_indent_pt: indent });
             }
             case 'remove_hanging_indent': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.removeHangingIndent(args?.section_index, args?.paragraph_index);
                 if (!result)
-                    return error('Failed to remove hanging indent. Check section/paragraph indices.');
-                return success({ message: 'Hanging indent removed' });
+                    return (0, ToolResult_1.error)('Failed to remove hanging indent. Check section/paragraph indices.');
+                return (0, ToolResult_1.success)({ message: 'Hanging indent removed' });
             }
             // === Table Cell Hanging Indent (테이블 셀 내어쓰기) ===
             case 'set_table_cell_hanging_indent': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.setTableCellHangingIndent(args?.section_index, args?.table_index, args?.row, args?.col, args?.paragraph_index, args?.indent_pt);
                 if (!result)
-                    return error('Failed to set hanging indent. Check indices and indent value (must be positive).');
-                return success({ message: `Table cell hanging indent set to ${args?.indent_pt}pt` });
+                    return (0, ToolResult_1.error)('Failed to set hanging indent. Check indices and indent value (must be positive).');
+                return (0, ToolResult_1.success)({ message: `Table cell hanging indent set to ${args?.indent_pt}pt` });
             }
             case 'get_table_cell_hanging_indent': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const indent = doc.getTableCellHangingIndent(args?.section_index, args?.table_index, args?.row, args?.col, args?.paragraph_index);
                 if (indent === null)
-                    return error('Invalid indices (section, table, row, col, or paragraph)');
-                return success({ hanging_indent_pt: indent });
+                    return (0, ToolResult_1.error)('Invalid indices (section, table, row, col, or paragraph)');
+                return (0, ToolResult_1.success)({ hanging_indent_pt: indent });
             }
             case 'remove_table_cell_hanging_indent': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.removeTableCellHangingIndent(args?.section_index, args?.table_index, args?.row, args?.col, args?.paragraph_index);
                 if (!result)
-                    return error('Failed to remove hanging indent. Check indices.');
-                return success({ message: 'Table cell hanging indent removed' });
+                    return (0, ToolResult_1.error)('Failed to remove hanging indent. Check indices.');
+                return (0, ToolResult_1.success)({ message: 'Table cell hanging indent removed' });
             }
             case 'set_auto_hanging_indent': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 // Use async version to read actual font size from document
                 const fontSizeArg = args?.font_size;
                 const indentPt = fontSizeArg !== undefined
@@ -2744,16 +2736,16 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     : await doc.setAutoHangingIndentAsync(args?.section_index, args?.paragraph_index, 10 // fallback font size
                     );
                 if (indentPt === 0) {
-                    return success({ message: 'No marker detected in paragraph text. No hanging indent applied.', indent_pt: 0 });
+                    return (0, ToolResult_1.success)({ message: 'No marker detected in paragraph text. No hanging indent applied.', indent_pt: 0 });
                 }
-                return success({ message: `Auto hanging indent applied: ${indentPt.toFixed(2)}pt`, indent_pt: indentPt });
+                return (0, ToolResult_1.success)({ message: `Auto hanging indent applied: ${indentPt.toFixed(2)}pt`, indent_pt: indentPt });
             }
             case 'set_table_cell_auto_hanging_indent': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 // Use async version to read actual font size from document
                 const fontSizeArg = args?.font_size;
                 const indentPt = fontSizeArg !== undefined
@@ -2761,21 +2753,21 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     : await doc.setTableCellAutoHangingIndentAsync(args?.section_index, args?.table_index, args?.row, args?.col, args?.paragraph_index, 10 // fallback font size
                     );
                 if (indentPt === 0) {
-                    return success({ message: 'No marker detected in cell text. No hanging indent applied.', indent_pt: 0 });
+                    return (0, ToolResult_1.success)({ message: 'No marker detected in cell text. No hanging indent applied.', indent_pt: 0 });
                 }
-                return success({ message: `Auto hanging indent applied to cell: ${indentPt.toFixed(2)}pt`, indent_pt: indentPt });
+                return (0, ToolResult_1.success)({ message: `Auto hanging indent applied to cell: ${indentPt.toFixed(2)}pt`, indent_pt: indentPt });
             }
             // === Search & Replace ===
             case 'search_text': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const results = doc.searchText(args?.query, {
                     caseSensitive: args?.case_sensitive,
                     regex: args?.regex,
                     includeTables: args?.include_tables !== false, // default true
                 });
-                return success({
+                return (0, ToolResult_1.success)({
                     query: args?.query,
                     total_matches: results.reduce((sum, r) => sum + r.count, 0),
                     locations: results,
@@ -2784,47 +2776,47 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'replace_text': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const count = doc.replaceText(args?.old_text, args?.new_text, {
                     caseSensitive: args?.case_sensitive,
                     regex: args?.regex,
                     replaceAll: args?.replace_all ?? true,
                 });
-                return success({ message: `Replaced ${count} occurrence(s)`, count });
+                return (0, ToolResult_1.success)({ message: `Replaced ${count} occurrence(s)`, count });
             }
             case 'batch_replace': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const replacements = args?.replacements;
                 if (!replacements)
-                    return error('replacements array is required');
+                    return (0, ToolResult_1.error)('replacements array is required');
                 const results = [];
                 for (const { old_text, new_text } of replacements) {
                     const count = doc.replaceText(old_text, new_text);
                     results.push({ old_text, new_text, count });
                 }
-                return success({ results });
+                return (0, ToolResult_1.success)({ results });
             }
             case 'replace_text_in_cell': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.replaceTextInCell(args?.section_index, args?.table_index, args?.row, args?.col, args?.old_text, args?.new_text, {
                     caseSensitive: args?.case_sensitive,
                     regex: args?.regex,
                     replaceAll: args?.replace_all ?? true,
                 });
                 if (!result.success) {
-                    return error(result.error || 'Replace failed');
+                    return (0, ToolResult_1.error)(result.error || 'Replace failed');
                 }
-                return success({
+                return (0, ToolResult_1.success)({
                     message: `Replaced ${result.count} occurrence(s) in cell [${args?.row}, ${args?.col}]`,
                     count: result.count,
                 });
@@ -2833,105 +2825,105 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'get_tables': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ tables: doc.getTables() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ tables: doc.getTables() });
             }
             case 'get_table_map': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ table_map: doc.getTableMap() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ table_map: doc.getTableMap() });
             }
             case 'find_empty_tables': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ empty_tables: doc.findEmptyTables() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ empty_tables: doc.findEmptyTables() });
             }
             case 'get_tables_by_section': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const sectionIndex = args?.section_index;
                 if (typeof sectionIndex !== 'number')
-                    return error('section_index is required');
-                return success({ tables: doc.getTablesBySection(sectionIndex) });
+                    return (0, ToolResult_1.error)('section_index is required');
+                return (0, ToolResult_1.success)({ tables: doc.getTablesBySection(sectionIndex) });
             }
             case 'find_table_by_header': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const searchText = args?.search_text;
                 if (!searchText)
-                    return error('search_text is required');
-                return success({ tables: doc.findTableByHeader(searchText) });
+                    return (0, ToolResult_1.error)('search_text is required');
+                return (0, ToolResult_1.success)({ tables: doc.findTableByHeader(searchText) });
             }
             case 'get_tables_summary': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const startIndex = args?.start_index;
                 const endIndex = args?.end_index;
-                return success({ tables: doc.getTablesSummary(startIndex, endIndex) });
+                return (0, ToolResult_1.success)({ tables: doc.getTablesSummary(startIndex, endIndex) });
             }
             case 'get_document_outline': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ outline: doc.getDocumentOutline() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ outline: doc.getDocumentOutline() });
             }
             // === Position/Index Helper Handlers ===
             case 'get_element_index_for_table': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const tableIndex = args?.table_index;
                 if (typeof tableIndex !== 'number')
-                    return error('table_index is required');
+                    return (0, ToolResult_1.error)('table_index is required');
                 const result = doc.getElementIndexForTable(tableIndex);
                 if (!result)
-                    return error(`Table ${tableIndex} not found`);
-                return success(result);
+                    return (0, ToolResult_1.error)(`Table ${tableIndex} not found`);
+                return (0, ToolResult_1.success)(result);
             }
             case 'find_paragraph_by_text': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const searchText = args?.search_text;
                 if (!searchText)
-                    return error('search_text is required');
+                    return (0, ToolResult_1.error)('search_text is required');
                 const sectionIndex = args?.section_index;
                 const results = doc.findParagraphByText(searchText, sectionIndex);
-                return success({ matches: results, count: results.length });
+                return (0, ToolResult_1.success)({ matches: results, count: results.length });
             }
             case 'get_insert_context': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const sectionIdx = args?.section_index;
                 const elementIdx = args?.element_index;
                 if (typeof sectionIdx !== 'number')
-                    return error('section_index is required');
+                    return (0, ToolResult_1.error)('section_index is required');
                 if (typeof elementIdx !== 'number')
-                    return error('element_index is required');
+                    return (0, ToolResult_1.error)('element_index is required');
                 const contextRange = args?.context_range;
                 const result = doc.getInsertContext(sectionIdx, elementIdx, contextRange);
                 if (!result)
-                    return error('Invalid section or element index');
-                return success(result);
+                    return (0, ToolResult_1.error)('Invalid section or element index');
+                return (0, ToolResult_1.success)(result);
             }
             case 'find_insert_position_after_header': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const headerText = args?.header_text;
                 if (!headerText)
-                    return error('header_text is required');
+                    return (0, ToolResult_1.error)('header_text is required');
                 const searchIn = args?.search_in || 'all';
                 const result = doc.findInsertPositionAfterHeader(headerText, searchIn);
                 if (!result)
-                    return error(`Text "${headerText}" not found in ${searchIn === 'all' ? 'paragraphs or table cells' : searchIn}`);
-                return success({
+                    return (0, ToolResult_1.error)(`Text "${headerText}" not found in ${searchIn === 'all' ? 'paragraphs or table cells' : searchIn}`);
+                return (0, ToolResult_1.success)({
                     ...result,
                     usage_hint: result.found_in === 'table_cell'
                         ? `Found in table cell. Use section_index=${result.section_index} and after_index=${result.insert_after} to insert AFTER this table, or use insert_image_in_cell with table_index=${result.table_info?.table_index}, row=${result.table_info?.row}, col=${result.table_info?.col} to insert INSIDE this cell.`
@@ -2941,14 +2933,14 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'find_insert_position_after_table': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const tableIndex = args?.table_index;
                 if (typeof tableIndex !== 'number')
-                    return error('table_index is required');
+                    return (0, ToolResult_1.error)('table_index is required');
                 const result = doc.findInsertPositionAfterTable(tableIndex);
                 if (!result)
-                    return error(`Table ${tableIndex} not found`);
-                return success({
+                    return (0, ToolResult_1.error)(`Table ${tableIndex} not found`);
+                return (0, ToolResult_1.success)({
                     ...result,
                     usage_hint: `Use section_index=${result.section_index} and after_index=${result.insert_after} in insert_image/render_mermaid`,
                 });
@@ -2956,28 +2948,28 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'get_table': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const table = doc.getTable(args?.section_index, args?.table_index);
                 if (!table)
-                    return error('Table not found');
-                return success(table);
+                    return (0, ToolResult_1.error)('Table not found');
+                return (0, ToolResult_1.success)(table);
             }
             case 'get_table_cell': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const cell = doc.getTableCell(args?.section_index, args?.table_index, args?.row, args?.col);
                 if (!cell)
-                    return error('Cell not found');
-                return success(cell);
+                    return (0, ToolResult_1.error)('Cell not found');
+                return (0, ToolResult_1.success)(cell);
             }
             case 'update_table_cell': {
                 const docId = args?.doc_id;
                 const doc = getDoc(docId);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 // Use document lock to prevent race conditions during parallel updates
                 return await withDocumentLock(docId, async () => {
                     const sectionIndex = args?.section_index;
@@ -2986,7 +2978,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     const col = args?.col;
                     const charShapeId = args?.char_shape_id;
                     if (!doc.updateTableCell(sectionIndex, tableIndex, row, col, args?.text, charShapeId)) {
-                        return error('Failed to update cell');
+                        return (0, ToolResult_1.error)('Failed to update cell');
                     }
                     // Auto hanging indent (default: true)
                     // Apply to ALL lines in the text, not just the first paragraph
@@ -3009,73 +3001,73 @@ Call get_tool_guide with: template, table, image, search, read, create`
                         }
                     }
                     if (appliedIndents.length > 0) {
-                        return success({
+                        return (0, ToolResult_1.success)({
                             message: `Cell updated with hanging indent applied to ${appliedIndents.length} paragraph(s)`,
                             indent_pts: appliedIndents
                         });
                     }
-                    return success({ message: 'Cell updated' });
+                    return (0, ToolResult_1.success)({ message: 'Cell updated' });
                 });
             }
             case 'find_cell_by_label': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const results = doc.findCellByLabel(args?.label_text, args?.direction);
-                return success({ matches: results, count: results.length });
+                return (0, ToolResult_1.success)({ matches: results, count: results.length });
             }
             case 'fill_by_path': {
                 const docId = args?.doc_id;
                 const doc = getDoc(docId);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 // Use document lock to prevent race conditions
                 return await withDocumentLock(docId, async () => {
                     const result = doc.fillByPath(args?.mappings);
-                    return success(result);
+                    return (0, ToolResult_1.success)(result);
                 });
             }
             case 'get_cell_context': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const globalIdx = args?.table_index;
                 const location = doc.convertGlobalToLocalTableIndex(globalIdx);
                 if (!location) {
-                    return error(`Table with global index ${globalIdx} not found`);
+                    return (0, ToolResult_1.error)(`Table with global index ${globalIdx} not found`);
                 }
                 const context = doc.getCellContext(globalIdx, args?.row, args?.col, args?.depth);
                 if (!context) {
-                    return error('Failed to get cell context');
+                    return (0, ToolResult_1.error)('Failed to get cell context');
                 }
-                return success(context);
+                return (0, ToolResult_1.success)(context);
             }
             case 'batch_fill_table': {
                 const docId = args?.doc_id;
                 const doc = getDoc(docId);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 // Use document lock to prevent race conditions
                 return await withDocumentLock(docId, async () => {
                     const globalIdx = args?.table_index;
                     const location = doc.convertGlobalToLocalTableIndex(globalIdx);
                     if (!location) {
-                        return error(`Table with global index ${globalIdx} not found`);
+                        return (0, ToolResult_1.error)(`Table with global index ${globalIdx} not found`);
                     }
                     const result = doc.batchFillTable(globalIdx, args?.data, args?.start_row, args?.start_col);
-                    return success(result);
+                    return (0, ToolResult_1.success)(result);
                 });
             }
             case 'set_cell_properties': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const props = {};
                 if (args?.width)
                     props.width = args.width;
@@ -3086,70 +3078,70 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 if (args?.vertical_align)
                     props.verticalAlign = args.vertical_align;
                 if (doc.setCellProperties(args?.section_index, args?.table_index, args?.row, args?.col, props)) {
-                    return success({ message: 'Cell properties updated' });
+                    return (0, ToolResult_1.success)({ message: 'Cell properties updated' });
                 }
-                return error('Failed to update cell properties');
+                return (0, ToolResult_1.error)('Failed to update cell properties');
             }
             case 'merge_cells': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.mergeCells(args?.section_index, args?.table_index, args?.start_row, args?.start_col, args?.end_row, args?.end_col)) {
                     const colSpan = args?.end_col - args?.start_col + 1;
                     const rowSpan = args?.end_row - args?.start_row + 1;
-                    return success({
+                    return (0, ToolResult_1.success)({
                         message: `Cells merged successfully`,
                         colSpan,
                         rowSpan,
                         masterCell: { row: args?.start_row, col: args?.start_col }
                     });
                 }
-                return error('Failed to merge cells. Check that the range is valid and cells are not already merged.');
+                return (0, ToolResult_1.error)('Failed to merge cells. Check that the range is valid and cells are not already merged.');
             }
             case 'split_cell': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.splitCell(args?.section_index, args?.table_index, args?.row, args?.col)) {
-                    return success({
+                    return (0, ToolResult_1.success)({
                         message: `Cell split successfully`,
                         cell: { row: args?.row, col: args?.col }
                     });
                 }
-                return error('Failed to split cell. Check that the cell is actually merged (colSpan > 1 or rowSpan > 1).');
+                return (0, ToolResult_1.error)('Failed to split cell. Check that the cell is actually merged (colSpan > 1 or rowSpan > 1).');
             }
             case 'insert_table_row': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.insertTableRow(args?.section_index, args?.table_index, args?.after_row, args?.cell_texts)) {
-                    return success({ message: 'Row inserted' });
+                    return (0, ToolResult_1.success)({ message: 'Row inserted' });
                 }
-                return error('Failed to insert row');
+                return (0, ToolResult_1.error)('Failed to insert row');
             }
             case 'delete_table': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.deleteTable(args?.section_index, args?.table_index)) {
-                    return success({ message: 'Table deleted' });
+                    return (0, ToolResult_1.success)({ message: 'Table deleted' });
                 }
-                return error('Failed to delete table');
+                return (0, ToolResult_1.error)('Failed to delete table');
             }
             case 'delete_table_row': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const sectionIndex = args?.section_index;
                 const tableIndex = args?.table_index;
                 const allTables = doc.getTables();
@@ -3157,57 +3149,57 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 const wasOnlyRow = table && table.rows === 1;
                 if (doc.deleteTableRow(args?.section_index, args?.table_index, args?.row_index)) {
                     if (wasOnlyRow) {
-                        return success({ message: 'Table deleted (was only row)' });
+                        return (0, ToolResult_1.success)({ message: 'Table deleted (was only row)' });
                     }
-                    return success({ message: 'Row deleted' });
+                    return (0, ToolResult_1.success)({ message: 'Row deleted' });
                 }
-                return error('Failed to delete row');
+                return (0, ToolResult_1.error)('Failed to delete row');
             }
             case 'insert_table_column': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.insertTableColumn(args?.section_index, args?.table_index, args?.after_col)) {
-                    return success({ message: 'Column inserted' });
+                    return (0, ToolResult_1.success)({ message: 'Column inserted' });
                 }
-                return error('Failed to insert column');
+                return (0, ToolResult_1.error)('Failed to insert column');
             }
             case 'delete_table_column': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.deleteTableColumn(args?.section_index, args?.table_index, args?.col_index)) {
-                    return success({ message: 'Column deleted' });
+                    return (0, ToolResult_1.success)({ message: 'Column deleted' });
                 }
-                return error('Failed to delete column');
+                return (0, ToolResult_1.error)('Failed to delete column');
             }
             case 'get_table_as_csv': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const csv = doc.getTableAsCsv(args?.section_index, args?.table_index, args?.delimiter || ',');
                 if (!csv)
-                    return error('Table not found');
-                return success({ csv });
+                    return (0, ToolResult_1.error)('Table not found');
+                return (0, ToolResult_1.success)({ csv });
             }
             // === Page Settings ===
             case 'get_page_settings': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const settings = doc.getPageSettings(args?.section_index || 0);
-                return success({ settings });
+                return (0, ToolResult_1.success)({ settings });
             }
             case 'set_page_settings': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const settings = {};
                 if (args?.width)
                     settings.width = args.width;
@@ -3224,85 +3216,85 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 if (args?.orientation)
                     settings.orientation = args.orientation;
                 if (doc.setPageSettings(args?.section_index || 0, settings)) {
-                    return success({ message: 'Page settings updated' });
+                    return (0, ToolResult_1.success)({ message: 'Page settings updated' });
                 }
-                return error('Failed to update page settings');
+                return (0, ToolResult_1.error)('Failed to update page settings');
             }
             // === Copy/Move ===
             case 'copy_paragraph': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.copyParagraph(args?.source_section, args?.source_paragraph, args?.target_section, args?.target_after)) {
-                    return success({ message: 'Paragraph copied' });
+                    return (0, ToolResult_1.success)({ message: 'Paragraph copied' });
                 }
-                return error('Failed to copy paragraph');
+                return (0, ToolResult_1.error)('Failed to copy paragraph');
             }
             case 'move_paragraph': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.moveParagraph(args?.source_section, args?.source_paragraph, args?.target_section, args?.target_after)) {
-                    return success({ message: 'Paragraph moved' });
+                    return (0, ToolResult_1.success)({ message: 'Paragraph moved' });
                 }
-                return error('Failed to move paragraph');
+                return (0, ToolResult_1.error)('Failed to move paragraph');
             }
             case 'move_table': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.moveTable(args?.section_index, args?.table_index, args?.target_section_index, args?.target_after_index);
                 if (result.success) {
-                    return success({ message: 'Table move scheduled. Changes will be applied on save.' });
+                    return (0, ToolResult_1.success)({ message: 'Table move scheduled. Changes will be applied on save.' });
                 }
-                return error(result.error || 'Failed to move table');
+                return (0, ToolResult_1.error)(result.error || 'Failed to move table');
             }
             case 'copy_table': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.copyTable(args?.section_index, args?.table_index, args?.target_section_index, args?.target_after_index);
                 if (result.success) {
-                    return success({ message: 'Table copy scheduled. Changes will be applied on save.' });
+                    return (0, ToolResult_1.success)({ message: 'Table copy scheduled. Changes will be applied on save.' });
                 }
-                return error(result.error || 'Failed to copy table');
+                return (0, ToolResult_1.error)(result.error || 'Failed to copy table');
             }
             // === Statistics ===
             case 'get_word_count': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success(doc.getWordCount());
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)(doc.getWordCount());
             }
             // === Images ===
             case 'get_images': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ images: doc.getImages() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ images: doc.getImages() });
             }
             // === Export ===
             case 'export_to_text': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const text = doc.getAllText();
                 const outputPath = args?.output_path;
                 fs.writeFileSync(outputPath, text, 'utf-8');
-                return success({ message: `Exported to ${outputPath}`, characters: text.length });
+                return (0, ToolResult_1.success)({ message: `Exported to ${outputPath}`, characters: text.length });
             }
             case 'export_to_html': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 let html = '<!DOCTYPE html><html><head><meta charset="UTF-8">';
                 html += '<style>body{font-family:sans-serif;max-width:800px;margin:0 auto;padding:20px;}table{border-collapse:collapse;width:100%;}td,th{border:1px solid #ccc;padding:8px;}</style>';
                 html += '</head><body>';
@@ -3331,13 +3323,13 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 html += '</body></html>';
                 const outputPath = args?.output_path;
                 fs.writeFileSync(outputPath, html, 'utf-8');
-                return success({ message: `Exported to ${outputPath}` });
+                return (0, ToolResult_1.success)({ message: `Exported to ${outputPath}` });
             }
             // === Undo/Redo ===
             case 'undo': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const count = args?.count || 1;
                 let undoneCount = 0;
                 for (let i = 0; i < count; i++) {
@@ -3349,19 +3341,19 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     }
                 }
                 if (undoneCount > 0) {
-                    return success({
+                    return (0, ToolResult_1.success)({
                         message: `Undo successful (${undoneCount}/${count})`,
                         undone_count: undoneCount,
                         canUndo: doc.canUndo(),
                         canRedo: doc.canRedo()
                     });
                 }
-                return error('Nothing to undo');
+                return (0, ToolResult_1.error)('Nothing to undo');
             }
             case 'redo': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const count = args?.count || 1;
                 let redoneCount = 0;
                 for (let i = 0; i < count; i++) {
@@ -3373,155 +3365,155 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     }
                 }
                 if (redoneCount > 0) {
-                    return success({
+                    return (0, ToolResult_1.success)({
                         message: `Redo successful (${redoneCount}/${count})`,
                         redone_count: redoneCount,
                         canUndo: doc.canUndo(),
                         canRedo: doc.canRedo()
                     });
                 }
-                return error('Nothing to redo');
+                return (0, ToolResult_1.error)('Nothing to redo');
             }
             // === Table Creation ===
             case 'insert_table': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.insertTable(args?.section_index, args?.after_index, args?.rows, args?.cols, { width: args?.width });
                 if (!result)
-                    return error('Failed to insert table');
-                return success({ message: 'Table inserted', tableIndex: result.tableIndex });
+                    return (0, ToolResult_1.error)('Failed to insert table');
+                return (0, ToolResult_1.success)({ message: 'Table inserted', tableIndex: result.tableIndex });
             }
             case 'insert_nested_table': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.insertNestedTable(args?.section_index, args?.parent_table_index, args?.row, args?.col, args?.nested_rows, args?.nested_cols, { data: args?.data });
                 if (!result.success)
-                    return error(result.error || 'Failed to insert nested table');
-                return success({ message: 'Nested table inserted successfully' });
+                    return (0, ToolResult_1.error)(result.error || 'Failed to insert nested table');
+                return (0, ToolResult_1.success)({ message: 'Nested table inserted successfully' });
             }
             // === Header/Footer ===
             case 'get_header': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const result = doc.getHeader(args?.section_index || 0);
-                return success({ header: result });
+                return (0, ToolResult_1.success)({ header: result });
             }
             case 'set_header': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.setHeader(args?.section_index || 0, args?.text)) {
-                    return success({ message: 'Header set successfully' });
+                    return (0, ToolResult_1.success)({ message: 'Header set successfully' });
                 }
-                return error('Failed to set header');
+                return (0, ToolResult_1.error)('Failed to set header');
             }
             case 'get_footer': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const result = doc.getFooter(args?.section_index || 0);
-                return success({ footer: result });
+                return (0, ToolResult_1.success)({ footer: result });
             }
             case 'set_footer': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.setFooter(args?.section_index || 0, args?.text)) {
-                    return success({ message: 'Footer set successfully' });
+                    return (0, ToolResult_1.success)({ message: 'Footer set successfully' });
                 }
-                return error('Failed to set footer');
+                return (0, ToolResult_1.error)('Failed to set footer');
             }
             // === Footnotes/Endnotes ===
             case 'get_footnotes': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ footnotes: doc.getFootnotes() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ footnotes: doc.getFootnotes() });
             }
             case 'insert_footnote': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.insertFootnote(args?.section_index, args?.paragraph_index, args?.text);
                 if (!result)
-                    return error('Failed to insert footnote');
-                return success({ message: 'Footnote inserted', id: result.id });
+                    return (0, ToolResult_1.error)('Failed to insert footnote');
+                return (0, ToolResult_1.success)({ message: 'Footnote inserted', id: result.id });
             }
             case 'get_endnotes': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ endnotes: doc.getEndnotes() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ endnotes: doc.getEndnotes() });
             }
             case 'insert_endnote': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.insertEndnote(args?.section_index, args?.paragraph_index, args?.text);
                 if (!result)
-                    return error('Failed to insert endnote');
-                return success({ message: 'Endnote inserted', id: result.id });
+                    return (0, ToolResult_1.error)('Failed to insert endnote');
+                return (0, ToolResult_1.success)({ message: 'Endnote inserted', id: result.id });
             }
             // === Bookmarks/Hyperlinks ===
             case 'get_bookmarks': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ bookmarks: doc.getBookmarks() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ bookmarks: doc.getBookmarks() });
             }
             case 'insert_bookmark': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.insertBookmark(args?.section_index, args?.paragraph_index, args?.name)) {
-                    return success({ message: 'Bookmark inserted' });
+                    return (0, ToolResult_1.success)({ message: 'Bookmark inserted' });
                 }
-                return error('Failed to insert bookmark');
+                return (0, ToolResult_1.error)('Failed to insert bookmark');
             }
             case 'get_hyperlinks': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ hyperlinks: doc.getHyperlinks() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ hyperlinks: doc.getHyperlinks() });
             }
             case 'insert_hyperlink': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.insertHyperlink(args?.section_index, args?.paragraph_index, args?.url, args?.text)) {
-                    return success({ message: 'Hyperlink inserted' });
+                    return (0, ToolResult_1.success)({ message: 'Hyperlink inserted' });
                 }
-                return error('Failed to insert hyperlink');
+                return (0, ToolResult_1.error)('Failed to insert hyperlink');
             }
             // === Image Operations ===
             case 'insert_image': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const imagePath = args?.image_path;
                 if (!fs.existsSync(imagePath))
-                    return error('Image file not found');
+                    return (0, ToolResult_1.error)('Image file not found');
                 // Resolve position using after_table, after_header, or direct indices
                 let sectionIndex = args?.section_index;
                 let afterIndex = args?.after_index;
@@ -3532,7 +3524,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     // Insert after a specific table
                     const pos = doc.findInsertPositionAfterTable(afterTable);
                     if (!pos)
-                        return error(`Table ${afterTable} not found`);
+                        return (0, ToolResult_1.error)(`Table ${afterTable} not found`);
                     sectionIndex = pos.section_index;
                     afterIndex = pos.insert_after;
                     insertedAfter = `table ${afterTable} ("${pos.table_info.header.substring(0, 50)}")`;
@@ -3541,7 +3533,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     // Insert after a header paragraph
                     const pos = doc.findInsertPositionAfterHeader(afterHeader);
                     if (!pos)
-                        return error(`Header "${afterHeader}" not found`);
+                        return (0, ToolResult_1.error)(`Header "${afterHeader}" not found`);
                     sectionIndex = pos.section_index;
                     afterIndex = pos.insert_after;
                     insertedAfter = `header "${pos.header_found.substring(0, 50)}"`;
@@ -3549,9 +3541,9 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 else {
                     // Use direct indices
                     if (sectionIndex === undefined)
-                        return error('section_index is required when not using after_table or after_header');
+                        return (0, ToolResult_1.error)('section_index is required when not using after_table or after_header');
                     if (afterIndex === undefined)
-                        return error('after_index is required when not using after_table or after_header');
+                        return (0, ToolResult_1.error)('after_index is required when not using after_table or after_header');
                     insertedAfter = `element ${afterIndex}`;
                 }
                 const imageData = fs.readFileSync(imagePath);
@@ -3587,10 +3579,10 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     headerText: afterHeader, // Pass header text for precise XML positioning
                 });
                 if (!result)
-                    return error('Failed to insert image');
+                    return (0, ToolResult_1.error)('Failed to insert image');
                 // Get context around insertion point for verification
                 const context = doc.getInsertContext(sectionIndex, afterIndex + 1, 1);
-                return success({
+                return (0, ToolResult_1.success)({
                     message: `Image inserted after ${insertedAfter}`,
                     id: result.id,
                     actualWidth: result.actualWidth,
@@ -3606,43 +3598,43 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'update_image_size': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 // Find image ID from section and index
                 const images = doc.getImages();
                 const imageIndex = args?.image_index;
                 if (imageIndex < 0 || imageIndex >= images.length)
-                    return error('Image not found');
+                    return (0, ToolResult_1.error)('Image not found');
                 if (doc.updateImageSize(images[imageIndex].id, args?.width, args?.height)) {
-                    return success({ message: 'Image size updated' });
+                    return (0, ToolResult_1.success)({ message: 'Image size updated' });
                 }
-                return error('Failed to update image size');
+                return (0, ToolResult_1.error)('Failed to update image size');
             }
             case 'delete_image': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const images = doc.getImages();
                 const imageIndex = args?.image_index;
                 if (imageIndex < 0 || imageIndex >= images.length)
-                    return error('Image not found');
+                    return (0, ToolResult_1.error)('Image not found');
                 if (doc.deleteImage(images[imageIndex].id)) {
-                    return success({ message: 'Image deleted' });
+                    return (0, ToolResult_1.success)({ message: 'Image deleted' });
                 }
-                return error('Failed to delete image');
+                return (0, ToolResult_1.error)('Failed to delete image');
             }
             case 'render_mermaid': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const mermaidCode = args?.mermaid_code;
                 if (!mermaidCode)
-                    return error('Mermaid code is required');
+                    return (0, ToolResult_1.error)('Mermaid code is required');
                 // Resolve position using after_table, after_header, or direct indices
                 let sectionIndex = args?.section_index;
                 let afterIndex = args?.after_index;
@@ -3653,7 +3645,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     // Insert after a specific table
                     const pos = doc.findInsertPositionAfterTable(afterTable);
                     if (!pos)
-                        return error(`Table ${afterTable} not found`);
+                        return (0, ToolResult_1.error)(`Table ${afterTable} not found`);
                     sectionIndex = pos.section_index;
                     afterIndex = pos.insert_after;
                     insertedAfter = `table ${afterTable} ("${pos.table_info.header.substring(0, 50)}")`;
@@ -3662,7 +3654,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     // Insert after a header paragraph
                     const pos = doc.findInsertPositionAfterHeader(afterHeader);
                     if (!pos)
-                        return error(`Header "${afterHeader}" not found`);
+                        return (0, ToolResult_1.error)(`Header "${afterHeader}" not found`);
                     sectionIndex = pos.section_index;
                     afterIndex = pos.insert_after;
                     insertedAfter = `header "${pos.header_found.substring(0, 50)}"`;
@@ -3671,7 +3663,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     // Use direct indices (default section to 0)
                     sectionIndex = sectionIndex ?? 0;
                     if (afterIndex === undefined)
-                        return error('after_index is required when not using after_table or after_header');
+                        return (0, ToolResult_1.error)('after_index is required when not using after_table or after_header');
                     insertedAfter = `element ${afterIndex}`;
                 }
                 // Build position options from args
@@ -3699,7 +3691,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 if (result.success) {
                     // Get context around insertion point for verification
                     const context = doc.getInsertContext(sectionIndex, afterIndex + 1, 1);
-                    return success({
+                    return (0, ToolResult_1.success)({
                         message: `Mermaid diagram inserted after ${insertedAfter}`,
                         image_id: result.imageId,
                         actualWidth: result.actualWidth,
@@ -3712,24 +3704,24 @@ Call get_tool_guide with: template, table, image, search, read, create`
                         } : undefined,
                     });
                 }
-                return error(result.error || 'Failed to render Mermaid diagram');
+                return (0, ToolResult_1.error)(result.error || 'Failed to render Mermaid diagram');
             }
             case 'insert_image_in_cell': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const imagePath = args?.image_path;
                 if (!fs.existsSync(imagePath))
-                    return error('Image file not found');
+                    return (0, ToolResult_1.error)('Image file not found');
                 const globalTblIdx = args?.table_index;
                 const rowIdx = args?.row;
                 const colIdx = args?.col;
                 // Convert global table index to section and local index
                 const tableLocation = doc.convertGlobalToLocalTableIndex(globalTblIdx);
                 if (!tableLocation) {
-                    return error(`Table with global index ${globalTblIdx} not found. Use get_table_map to find valid table indices.`);
+                    return (0, ToolResult_1.error)(`Table with global index ${globalTblIdx} not found. Use get_table_map to find valid table indices.`);
                 }
                 const { section_index: secIdx, local_index: localTblIdx } = tableLocation;
                 const imageData = fs.readFileSync(imagePath);
@@ -3751,14 +3743,14 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     afterText,
                 });
                 if (!result)
-                    return error('Failed to insert image in cell. Check row/col indices.');
+                    return (0, ToolResult_1.error)('Failed to insert image in cell. Check row/col indices.');
                 // Get cell content for context using getTableCell
                 const cellInfo = doc.getTableCell(secIdx, localTblIdx, rowIdx, colIdx);
                 const cellText = cellInfo?.text?.substring(0, 30) || '';
                 const positionInfo = afterText
                     ? `after paragraph containing "${afterText}"`
                     : 'at the beginning';
-                return success({
+                return (0, ToolResult_1.success)({
                     message: `Image inserted in cell [${rowIdx}, ${colIdx}] of table ${globalTblIdx} ${positionInfo}`,
                     id: result.id,
                     actualWidth: result.actualWidth,
@@ -3769,19 +3761,19 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'render_mermaid_in_cell': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const mermaidCode = args?.mermaid_code;
                 if (!mermaidCode)
-                    return error('Mermaid code is required');
+                    return (0, ToolResult_1.error)('Mermaid code is required');
                 const globalTblIdx = args?.table_index;
                 const rowIdx = args?.row;
                 const colIdx = args?.col;
                 // Convert global table index to section and local index
                 const tableLocation = doc.convertGlobalToLocalTableIndex(globalTblIdx);
                 if (!tableLocation) {
-                    return error(`Table with global index ${globalTblIdx} not found. Use get_table_map to find valid table indices.`);
+                    return (0, ToolResult_1.error)(`Table with global index ${globalTblIdx} not found. Use get_table_map to find valid table indices.`);
                 }
                 const { section_index: secIdx, local_index: localTblIdx } = tableLocation;
                 // Fetch Mermaid diagram from mermaid.ink API using pako compression (same as renderMermaidToImage)
@@ -3808,7 +3800,7 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 try {
                     const response = await fetch(url);
                     if (!response.ok) {
-                        return error(`Failed to render Mermaid diagram: ${response.statusText}`);
+                        return (0, ToolResult_1.error)(`Failed to render Mermaid diagram: ${response.statusText}`);
                     }
                     const imageBuffer = Buffer.from(await response.arrayBuffer());
                     const afterText = args?.after_text;
@@ -3821,14 +3813,14 @@ Call get_tool_guide with: template, table, image, search, read, create`
                         afterText,
                     });
                     if (!result)
-                        return error('Failed to insert Mermaid diagram in cell. Check row/col indices.');
+                        return (0, ToolResult_1.error)('Failed to insert Mermaid diagram in cell. Check row/col indices.');
                     // Get cell content for context using getTableCell
                     const cellInfo = doc.getTableCell(secIdx, localTblIdx, rowIdx, colIdx);
                     const cellText = cellInfo?.text?.substring(0, 30) || '';
                     const positionInfo = afterText
                         ? `after paragraph containing "${afterText}"`
                         : 'at the beginning';
-                    return success({
+                    return (0, ToolResult_1.success)({
                         message: `Mermaid diagram inserted in cell [${rowIdx}, ${colIdx}] of table ${globalTblIdx} ${positionInfo}`,
                         image_id: result.id,
                         actualWidth: result.actualWidth,
@@ -3838,202 +3830,202 @@ Call get_tool_guide with: template, table, image, search, read, create`
                 }
                 catch (err) {
                     const errorMessage = err instanceof Error ? err.message : String(err);
-                    return error(`Failed to fetch Mermaid diagram: ${errorMessage}`);
+                    return (0, ToolResult_1.error)(`Failed to fetch Mermaid diagram: ${errorMessage}`);
                 }
             }
             // === Drawing Objects ===
             case 'insert_line': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.insertLine(args?.section_index, args?.x1, args?.y1, args?.x2, args?.y2, {
                     color: args?.stroke_color,
                     width: args?.stroke_width,
                 });
                 if (!result)
-                    return error('Failed to insert line');
-                return success({ message: 'Line inserted', id: result.id });
+                    return (0, ToolResult_1.error)('Failed to insert line');
+                return (0, ToolResult_1.success)({ message: 'Line inserted', id: result.id });
             }
             case 'insert_rect': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.insertRect(args?.section_index, args?.x, args?.y, args?.width, args?.height, {
                     fillColor: args?.fill_color,
                     strokeColor: args?.stroke_color,
                 });
                 if (!result)
-                    return error('Failed to insert rectangle');
-                return success({ message: 'Rectangle inserted', id: result.id });
+                    return (0, ToolResult_1.error)('Failed to insert rectangle');
+                return (0, ToolResult_1.success)({ message: 'Rectangle inserted', id: result.id });
             }
             case 'insert_ellipse': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.insertEllipse(args?.section_index, args?.cx, args?.cy, args?.rx, args?.ry, {
                     fillColor: args?.fill_color,
                     strokeColor: args?.stroke_color,
                 });
                 if (!result)
-                    return error('Failed to insert ellipse');
-                return success({ message: 'Ellipse inserted', id: result.id });
+                    return (0, ToolResult_1.error)('Failed to insert ellipse');
+                return (0, ToolResult_1.success)({ message: 'Ellipse inserted', id: result.id });
             }
             // === Equations ===
             case 'get_equations': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ equations: doc.getEquations() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ equations: doc.getEquations() });
             }
             case 'insert_equation': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.insertEquation(args?.section_index, args?.after_index, args?.script);
                 if (!result)
-                    return error('Failed to insert equation');
-                return success({ message: 'Equation inserted', id: result.id });
+                    return (0, ToolResult_1.error)('Failed to insert equation');
+                return (0, ToolResult_1.success)({ message: 'Equation inserted', id: result.id });
             }
             // === Memos ===
             case 'get_memos': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ memos: doc.getMemos() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ memos: doc.getMemos() });
             }
             case 'insert_memo': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const result = doc.insertMemo(args?.section_index, args?.paragraph_index, args?.content, args?.author);
                 if (!result)
-                    return error('Failed to insert memo');
-                return success({ message: 'Memo inserted', id: result.id });
+                    return (0, ToolResult_1.error)('Failed to insert memo');
+                return (0, ToolResult_1.success)({ message: 'Memo inserted', id: result.id });
             }
             case 'delete_memo': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.deleteMemo(args?.memo_id)) {
-                    return success({ message: 'Memo deleted' });
+                    return (0, ToolResult_1.success)({ message: 'Memo deleted' });
                 }
-                return error('Failed to delete memo');
+                return (0, ToolResult_1.error)('Failed to delete memo');
             }
             // === Sections ===
             case 'get_sections': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ sections: doc.getSections() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ sections: doc.getSections() });
             }
             case 'insert_section': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const newIndex = doc.insertSection(args?.after_index);
-                return success({ message: 'Section inserted', index: newIndex });
+                return (0, ToolResult_1.success)({ message: 'Section inserted', index: newIndex });
             }
             case 'delete_section': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.deleteSection(args?.section_index)) {
-                    return success({ message: 'Section deleted' });
+                    return (0, ToolResult_1.success)({ message: 'Section deleted' });
                 }
-                return error('Failed to delete section');
+                return (0, ToolResult_1.error)('Failed to delete section');
             }
             case 'get_section_xml': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const sectionIndex = args?.section_index ?? 0;
                 const xml = await doc.getSectionXml(sectionIndex);
                 if (xml === null) {
-                    return error(`Section ${sectionIndex} not found or document is HWP format`);
+                    return (0, ToolResult_1.error)(`Section ${sectionIndex} not found or document is HWP format`);
                 }
-                return success({ section_index: sectionIndex, xml });
+                return (0, ToolResult_1.success)({ section_index: sectionIndex, xml });
             }
             case 'set_section_xml': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const sectionIndex = args?.section_index ?? 0;
                 const xml = args?.xml;
                 const validate = args?.validate ?? true;
                 if (!xml) {
-                    return error('XML content is required');
+                    return (0, ToolResult_1.error)('XML content is required');
                 }
                 const result = await doc.setSectionXml(sectionIndex, xml, validate);
                 if (result.success) {
-                    return success({ message: `Section ${sectionIndex} XML replaced successfully` });
+                    return (0, ToolResult_1.success)({ message: `Section ${sectionIndex} XML replaced successfully` });
                 }
-                return error(result.error || 'Failed to set section XML');
+                return (0, ToolResult_1.error)(result.error || 'Failed to set section XML');
             }
             // === Styles ===
             case 'get_styles': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ styles: doc.getStyles() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ styles: doc.getStyles() });
             }
             case 'get_char_shapes': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ charShapes: doc.getCharShapes() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ charShapes: doc.getCharShapes() });
             }
             case 'get_para_shapes': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ paraShapes: doc.getParaShapes() });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ paraShapes: doc.getParaShapes() });
             }
             case 'apply_style': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.applyStyle(args?.section_index, args?.paragraph_index, args?.style_id)) {
-                    return success({ message: 'Style applied' });
+                    return (0, ToolResult_1.success)({ message: 'Style applied' });
                 }
-                return error('Failed to apply style');
+                return (0, ToolResult_1.error)('Failed to apply style');
             }
             // === Column Definition ===
             case 'get_column_def': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
-                return success({ columnDef: doc.getColumnDef(args?.section_index || 0) });
+                    return (0, ToolResult_1.error)('Document not found');
+                return (0, ToolResult_1.success)({ columnDef: doc.getColumnDef(args?.section_index || 0) });
             }
             case 'set_column_def': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 if (doc.setColumnDef(args?.section_index || 0, args?.count, args?.gap)) {
-                    return success({ message: 'Column definition set' });
+                    return (0, ToolResult_1.success)({ message: 'Column definition set' });
                 }
-                return error('Failed to set column definition');
+                return (0, ToolResult_1.error)('Failed to set column definition');
             }
             // === Create New Document ===
             case 'create_document': {
@@ -4047,12 +4039,12 @@ Call get_tool_guide with: template, table, image, search, read, create`
                     plannedPath = path.resolve(requestedPath);
                     const parentDirectory = path.dirname(plannedPath);
                     if (!fs.existsSync(parentDirectory)) {
-                        return error(`Directory does not exist: ${parentDirectory}`);
+                        return (0, ToolResult_1.error)(`Directory does not exist: ${parentDirectory}`);
                     }
                     doc.setPath(plannedPath);
                 }
                 openDocuments.set(docId, doc);
-                return success({
+                return (0, ToolResult_1.success)({
                     doc_id: docId,
                     format: 'hwpx',
                     path: plannedPath,
@@ -4065,10 +4057,10 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'analyze_xml': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const sectionIndex = args?.section_index;
                 const result = await doc.analyzeXml(sectionIndex);
-                return success({
+                return (0, ToolResult_1.success)({
                     has_issues: result.hasIssues,
                     summary: result.summary,
                     sections: result.sections.map(s => ({
@@ -4081,18 +4073,18 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'repair_xml': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const sectionIndex = args?.section_index;
                 if (sectionIndex === undefined)
-                    return error('section_index is required');
+                    return (0, ToolResult_1.error)('section_index is required');
                 const result = await doc.repairXml(sectionIndex, {
                     removeOrphanCloseTags: args?.remove_orphan_close_tags,
                     fixTableStructure: args?.fix_table_structure,
                     backup: args?.backup,
                 });
-                return success({
+                return (0, ToolResult_1.success)({
                     success: result.success,
                     message: result.message,
                     repairs_applied: result.repairsApplied,
@@ -4102,14 +4094,14 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'get_raw_section_xml': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const sectionIndex = args?.section_index;
                 if (sectionIndex === undefined)
-                    return error('section_index is required');
+                    return (0, ToolResult_1.error)('section_index is required');
                 const xml = await doc.getRawSectionXml(sectionIndex);
                 if (xml === null)
-                    return error(`Section ${sectionIndex} not found`);
-                return success({
+                    return (0, ToolResult_1.error)(`Section ${sectionIndex} not found`);
+                return (0, ToolResult_1.success)({
                     section_index: sectionIndex,
                     xml_length: xml.length,
                     xml: xml,
@@ -4118,25 +4110,25 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'set_raw_section_xml': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 if (doc.format === 'hwp')
-                    return error('HWP files are read-only');
+                    return (0, ToolResult_1.error)('HWP files are read-only');
                 const sectionIndex = args?.section_index;
                 const xml = args?.xml;
                 const validate = args?.validate !== false; // default: true
                 if (sectionIndex === undefined)
-                    return error('section_index is required');
+                    return (0, ToolResult_1.error)('section_index is required');
                 if (!xml)
-                    return error('xml is required');
+                    return (0, ToolResult_1.error)('xml is required');
                 const result = await doc.setRawSectionXml(sectionIndex, xml, validate);
                 if (result.success) {
-                    return success({
+                    return (0, ToolResult_1.success)({
                         success: true,
                         message: result.message,
                     });
                 }
                 else {
-                    return success({
+                    return (0, ToolResult_1.success)({
                         success: false,
                         message: result.message,
                         issues: result.issues,
@@ -4147,11 +4139,11 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'chunk_document': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const chunkSize = args?.chunk_size || 500;
                 const overlap = args?.overlap || 100;
                 const chunks = doc.chunkDocument(chunkSize, overlap);
-                return success({
+                return (0, ToolResult_1.success)({
                     total_chunks: chunks.length,
                     chunk_size: chunkSize,
                     overlap: overlap,
@@ -4170,14 +4162,14 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'search_chunks': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const query = args?.query;
                 if (!query)
-                    return error('query is required');
+                    return (0, ToolResult_1.error)('query is required');
                 const topK = args?.top_k || 5;
                 const minScore = args?.min_score || 0.1;
                 const results = doc.searchChunks(query, topK, minScore);
-                return success({
+                return (0, ToolResult_1.success)({
                     query,
                     total_results: results.length,
                     results: results.map(r => ({
@@ -4199,14 +4191,14 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'get_chunk_context': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const chunkId = args?.chunk_id;
                 if (!chunkId)
-                    return error('chunk_id is required');
+                    return (0, ToolResult_1.error)('chunk_id is required');
                 const before = args?.before || 1;
                 const after = args?.after || 1;
                 const context = doc.getChunkContext(chunkId, before, after);
-                return success({
+                return (0, ToolResult_1.success)({
                     center_index: context.centerIndex,
                     total_chunks: context.chunks.length,
                     chunks: context.chunks.map(c => ({
@@ -4223,9 +4215,9 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'extract_toc': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const toc = doc.extractToc();
-                return success({
+                return (0, ToolResult_1.success)({
                     total_entries: toc.length,
                     toc: toc.map(t => ({
                         level: t.level,
@@ -4239,9 +4231,9 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'build_position_index': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const index = doc.buildPositionIndex();
-                return success({
+                return (0, ToolResult_1.success)({
                     total_entries: index.length,
                     index: index.map(e => ({
                         id: e.id,
@@ -4258,9 +4250,9 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'get_position_index': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const index = doc.getPositionIndex();
-                return success({
+                return (0, ToolResult_1.success)({
                     total_entries: index.length,
                     index: index.map(e => ({
                         id: e.id,
@@ -4277,13 +4269,13 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'search_position_index': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const query = args?.query;
                 if (!query)
-                    return error('query is required');
+                    return (0, ToolResult_1.error)('query is required');
                 const type = args?.type;
                 const results = doc.searchPositionIndex(query, type);
-                return success({
+                return (0, ToolResult_1.success)({
                     query,
                     type_filter: type || 'all',
                     total_results: results.length,
@@ -4302,15 +4294,15 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'get_chunk_at_offset': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 const offset = args?.offset;
                 if (offset === undefined)
-                    return error('offset is required');
+                    return (0, ToolResult_1.error)('offset is required');
                 const chunk = doc.getChunkAtOffset(offset);
                 if (!chunk) {
-                    return success({ found: false, message: 'No chunk found at this offset' });
+                    return (0, ToolResult_1.success)({ found: false, message: 'No chunk found at this offset' });
                 }
-                return success({
+                return (0, ToolResult_1.success)({
                     found: true,
                     chunk: {
                         id: chunk.id,
@@ -4326,16 +4318,16 @@ Call get_tool_guide with: template, table, image, search, read, create`
             case 'invalidate_reading_cache': {
                 const doc = getDoc(args?.doc_id);
                 if (!doc)
-                    return error('Document not found');
+                    return (0, ToolResult_1.error)('Document not found');
                 doc.invalidateReadingCache();
-                return success({ success: true, message: 'Reading cache invalidated' });
+                return (0, ToolResult_1.success)({ success: true, message: 'Reading cache invalidated' });
             }
             default:
-                return error(`Unknown tool: ${name}`);
+                return (0, ToolResult_1.error)(`Unknown tool: ${name}`);
         }
     }
     catch (err) {
-        return error(err.message);
+        return (0, ToolResult_1.error)(err.message);
     }
 });
 // ============================================================
@@ -4344,16 +4336,6 @@ Call get_tool_guide with: template, table, image, search, read, create`
 function getDoc(docId) {
     return openDocuments.get(docId);
 }
-function success(data) {
-    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-}
-function error(message) {
-    // isError tells the MCP client the call failed. Without it, a missing
-    // argument or a refused write came back as a normal result whose body merely
-    // contained {"error": …}, and agents treated it as success (reported
-    // 2026-09-24). The JSON body is kept for clients that read it.
-    return { content: [{ type: 'text', text: JSON.stringify({ error: message }) }], isError: true };
-}
 function escapeHtml(text) {
     return text
         .replace(/&/g, '&amp;')