mcp-word-bridge 3.2.0

package/taskpane-app.js

@@ -0,0 +1,1329 @@
+/* MCP Word Bridge — Taskpane Application */
+const logEl = document.getElementById('log');
+const wordStatus = document.getElementById('word-status');
+const wsStatus = document.getElementById('ws-status');
+
+function log(msg, cls) {
+  const line = document.createElement('div');
+  line.className = cls || '';
+  line.textContent = new Date().toLocaleTimeString() + ' ' + msg;
+  logEl.appendChild(line);
+  logEl.scrollTop = logEl.scrollHeight;
+  if (logEl.children.length > 200) logEl.removeChild(logEl.firstChild);
+}
+
+// --- Word initialization ---
+let wordReady = false;
+Office.onReady(function(info) {
+  if (info.host === Office.HostType.Word) {
+    wordReady = true;
+    wordStatus.textContent = 'Word: connected ✓';
+    wordStatus.className = 'status ok';
+    log('Office.js ready (WordApi 1.9, Desktop 1.5)', 'log-ok');
+    connectWebSocket();
+  } else {
+    wordStatus.textContent = 'Word: wrong host';
+    wordStatus.className = 'status err';
+  }
+});
+
+// --- WebSocket ---
+let ws = null;
+function connectWebSocket() {
+  ws = new WebSocket('wss://localhost:3000/taskpane');
+  ws.onopen = function() {
+    wsStatus.textContent = 'WebSocket: connected ✓';
+    wsStatus.className = 'status ok';
+    log('WebSocket connected', 'log-ok');
+  };
+  ws.onclose = function() {
+    wsStatus.textContent = 'WebSocket: disconnected';
+    wsStatus.className = 'status warn';
+    setTimeout(connectWebSocket, 3000);
+  };
+  ws.onerror = function() { log('WebSocket error', 'log-err'); };
+  ws.onmessage = function(event) { handleCommand(JSON.parse(event.data)); };
+}
+
+function sendResponse(id, result) {
+  if (ws && ws.readyState === 1) ws.send(JSON.stringify({ type: 'response', id, result }));
+}
+function sendError(id, error) {
+  if (ws && ws.readyState === 1) ws.send(JSON.stringify({ type: 'response', id, error }));
+}
+
+// --- Command dispatcher ---
+async function handleCommand(cmd) {
+  log('← ' + cmd.action, 'log-cmd');
+  try {
+    const handler = commands[cmd.action];
+    if (!handler) throw new Error('Unknown action: ' + cmd.action);
+    const result = await handler(cmd.params || {});
+    log('→ ok', 'log-ok');
+    sendResponse(cmd.id, result);
+  } catch (e) {
+    log('→ ERR: ' + e.message, 'log-err');
+    sendError(cmd.id, e.message);
+  }
+}
+
+// --- Command registry ---
+const commands = {};
+
+// == BASIC ==
+commands.ping = async () => ({ status: 'ok', wordReady });
+
+commands.getApiVersion = async () => {
+  const sets = [
+    'WordApi 1.9','WordApi 1.8','WordApi 1.7','WordApi 1.6','WordApi 1.5',
+    'WordApi 1.4','WordApi 1.3','WordApi 1.2','WordApi 1.1',
+    'WordApiDesktop 1.5','WordApiDesktop 1.4','WordApiDesktop 1.3',
+    'WordApiDesktop 1.2','WordApiDesktop 1.1'
+  ];
+  const supported = {};
+  sets.forEach(s => {
+    const [name, ver] = s.split(' ');
+    supported[s] = Office.context.requirements.isSetSupported(name, ver);
+  });
+  return { platform: Office.context.platform, host: Office.context.host, diagnostics: Office.context.diagnostics, supportedSets: supported };
+};
+
+// == DOCUMENT TEXT ==
+commands.getDocumentText = () => Word.run(async (ctx) => {
+  const body = ctx.document.body;
+  body.load('text');
+  await ctx.sync();
+  return { text: body.text };
+});
+
+commands.getDocumentProperties = () => Word.run(async (ctx) => {
+  const props = ctx.document.properties;
+  props.load('title,subject,author,keywords,comments,lastAuthor,revisionNumber,creationDate,lastSaveTime,category,company,manager,format,applicationName,template,lastPrintDate,security');
+  ctx.document.load('changeTrackingMode');
+  await ctx.sync();
+  // Get file path using getFilePropertiesAsync
+  // Note: On macOS, this returns a sandbox container path with a content-derived name
+  // for documents that haven't been explicitly saved to a user-chosen location.
+  // We validate the path ends with a document extension to filter out garbage paths.
+  let path = null;
+  try {
+    const fileProps = await new Promise((resolve) => {
+      Office.context.document.getFilePropertiesAsync(resolve);
+    });
+    if (fileProps.status === Office.AsyncResultStatus.Succeeded && fileProps.value.url) {
+      const url = fileProps.value.url;
+      if (/\.(docx?|docm|dotx?|dotm)$/i.test(url)) {
+        path = url;
+      }
+      // else: path looks like a container-derived name (no extension) — discard it
+    }
+  } catch (e) {}
+  return { title: props.title, subject: props.subject, author: props.author, keywords: props.keywords, comments: props.comments, category: props.category, company: props.company, manager: props.manager, format: props.format, applicationName: props.applicationName, template: props.template, lastAuthor: props.lastAuthor, revisionNumber: props.revisionNumber, creationDate: props.creationDate, lastSaveTime: props.lastSaveTime, lastPrintDate: props.lastPrintDate, security: props.security, changeTrackingMode: ctx.document.changeTrackingMode, path: path };
+});
+
+commands.setDocumentProperties = (p) => Word.run(async (ctx) => {
+  const props = ctx.document.properties;
+  if (p.title !== undefined) props.title = p.title;
+  if (p.subject !== undefined) props.subject = p.subject;
+  if (p.author !== undefined) props.author = p.author;
+  if (p.keywords !== undefined) props.keywords = p.keywords;
+  if (p.comments !== undefined) props.comments = p.comments;
+  if (p.category !== undefined) props.category = p.category;
+  if (p.company !== undefined) props.company = p.company;
+  if (p.manager !== undefined) props.manager = p.manager;
+  if (p.format !== undefined) props.format = p.format;
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.setChangeTracking = (p) => Word.run(async (ctx) => {
+  // mode: 'TrackAll', 'TrackMineOnly', or 'Off'
+  ctx.document.changeTrackingMode = p.mode || 'TrackAll';
+  await ctx.sync();
+  return { success: true, mode: p.mode || 'TrackAll' };
+});
+
+// == PARAGRAPHS ==
+commands.getParagraphs = (p) => Word.run(async (ctx) => {
+  const paragraphs = ctx.document.body.paragraphs;
+  paragraphs.load('text,style,alignment,firstLineIndent,leftIndent,lineSpacing,isListItem,parentTableCellOrNullObject');
+  await ctx.sync();
+  const start = p.start || 0;
+  const end = p.end || paragraphs.items.length;
+  const items = [];
+  for (let i = start; i < Math.min(end, paragraphs.items.length); i++) {
+    const para = paragraphs.items[i];
+    const inTable = para.parentTableCellOrNullObject && !para.parentTableCellOrNullObject.isNullObject;
+    const isTocEntry = !!(para.style && para.style.startsWith('TOC')) || (para.style === '' && /\t\d+$/.test(para.text));
+    items.push({ index: i, text: para.text, style: para.style, alignment: para.alignment, isListItem: para.isListItem, inTable: inTable, isTocEntry: isTocEntry });
+  }
+  return { count: paragraphs.items.length, paragraphs: items };
+});
+
+commands.insertParagraph = (p) => Word.run(async (ctx) => {
+  // Normalize and validate alignment before any document mutation
+  // Official Word.Alignment enum: Left, Centered, Right, Justified (Mixed/Unknown are read-only)
+  const ALIGNMENT_MAP = { 'Left': 'Left', 'Center': 'Centered', 'Centered': 'Centered', 'Right': 'Right', 'Justify': 'Justified', 'Justified': 'Justified' };
+  let alignment = null;
+  if (p.alignment) {
+    alignment = ALIGNMENT_MAP[p.alignment];
+    if (!alignment) {
+      throw new Error('Invalid alignment: "' + p.alignment + '". Valid values: Left, Center, Right, Justified');
+    }
+  }
+  // Validate style exists (if provided)
+  const styleName = p.style || 'Normal';
+  if (p.style) {
+    const styleObj = ctx.document.getStyles().getByNameOrNullObject(p.style);
+    styleObj.load('nameLocal');
+    await ctx.sync();
+    if (styleObj.isNullObject) {
+      throw new Error('Style not found: "' + p.style + '". Use word_get_styles to see available styles.');
+    }
+  }
+  // Insert paragraph and apply style
+  const para = ctx.document.body.insertParagraph(p.text, p.location || 'End');
+  para.style = styleName;
+  await ctx.sync();
+  // Apply alignment in a separate sync
+  if (alignment) {
+    para.alignment = alignment;
+    await ctx.sync();
+  }
+  // For non-heading styles, reset font to prevent inheritance from prior formatted text
+  if (!styleName.startsWith('Heading')) {
+    let defaultSize = 12;
+    try {
+      const styleObj2 = ctx.document.getStyles().getByNameOrNullObject(styleName);
+      styleObj2.load('font/size');
+      await ctx.sync();
+      if (!styleObj2.isNullObject && styleObj2.font.size) defaultSize = styleObj2.font.size;
+    } catch (e) {
+      // Fallback: use 12pt if style lookup not supported
+    }
+    para.font.size = defaultSize;
+    await ctx.sync();
+  }
+  // Move cursor to end of inserted paragraph
+  const range = para.getRange('End');
+  range.select();
+  await ctx.sync();
+  const result = { success: true };
+  if (!p.text || p.text.trim() === '') result.warning = 'Empty paragraph inserted. Use delete_paragraph to remove if unintended.';
+  return result;
+});
+
+commands.deleteParagraph = (p) => Word.run(async (ctx) => {
+  if (p.index < 0) throw new Error('Index must be non-negative');
+  const paragraphs = ctx.document.body.paragraphs;
+  paragraphs.load('text');
+  await ctx.sync();
+  if (p.index >= paragraphs.items.length) throw new Error('Index out of range. Document has ' + paragraphs.items.length + ' paragraphs (0-indexed).');
+  paragraphs.items[p.index].delete();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.setParagraphStyle = (p) => Word.run(async (ctx) => {
+  if (p.index < 0) throw new Error('Index must be non-negative');
+  // Normalize and validate alignment
+  // Official Word.Alignment enum: Left, Centered, Right, Justified (Mixed/Unknown are read-only)
+  const ALIGNMENT_MAP = { 'Left': 'Left', 'Center': 'Centered', 'Centered': 'Centered', 'Right': 'Right', 'Justify': 'Justified', 'Justified': 'Justified' };
+  let alignment = null;
+  if (p.alignment) {
+    alignment = ALIGNMENT_MAP[p.alignment];
+    if (!alignment) {
+      throw new Error('Invalid alignment: "' + p.alignment + '". Valid values: Left, Center, Right, Justified');
+    }
+  }
+  if (!p.style && !p.alignment) {
+    throw new Error('At least one of "style" or "alignment" must be provided.');
+  }
+  const paragraphs = ctx.document.body.paragraphs;
+  paragraphs.load('text');
+  await ctx.sync();
+  if (p.index >= paragraphs.items.length) throw new Error('Paragraph index out of range. Document has ' + paragraphs.items.length + ' paragraphs (0-indexed).');
+  const para = paragraphs.items[p.index];
+  // Validate and apply style (if provided)
+  if (p.style) {
+    const styleObj = ctx.document.getStyles().getByNameOrNullObject(p.style);
+    styleObj.load('nameLocal');
+    await ctx.sync();
+    if (styleObj.isNullObject) {
+      throw new Error('Style not found: "' + p.style + '". Use word_get_styles to see available styles.');
+    }
+    para.style = p.style;
+    await ctx.sync();
+  }
+  // Apply alignment in a separate sync
+  if (alignment) {
+    para.alignment = alignment;
+    await ctx.sync();
+  }
+  return { success: true };
+});
+
+// == SEARCH & REPLACE ==
+commands.search = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.query, { matchCase: p.matchCase || false, matchWholeWord: p.matchWholeWord || false });
+  results.load('text');
+  await ctx.sync();
+  return { count: results.items.length, matches: results.items.slice(0, 30).map((r, i) => ({ index: i, text: r.text })) };
+});
+
+commands.searchAndReplace = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.find, { matchCase: p.matchCase || false, matchWholeWord: p.matchWholeWord || false });
+  results.load('text');
+  await ctx.sync();
+  const count = results.items.length;
+  let lastRange = null;
+  for (let i = 0; i < count; i++) {
+    lastRange = results.items[i].insertText(p.replace, Word.InsertLocation.replace);
+  }
+  if (lastRange) {
+    lastRange.getRange('End').select();
+  }
+  await ctx.sync();
+  return { replacements: count };
+});
+
+// == TEXT INSERTION ==
+commands.insertText = (p) => Word.run(async (ctx) => {
+  if (p.after && p.before) throw new Error('Provide only one of "after" or "before", not both.');
+  const anchor = p.after || p.before;
+  if (!anchor) throw new Error('Either "after" or "before" anchor text must be provided');
+  const results = ctx.document.body.search(anchor, { matchCase: p.matchCase || false });
+  results.load('text');
+  await ctx.sync();
+  if (results.items.length === 0) throw new Error('Anchor not found: ' + anchor);
+  const idx = p.occurrence || 0;
+  if (idx >= results.items.length) throw new Error('Occurrence index ' + idx + ' is out of range (valid: 0 to ' + (results.items.length - 1) + ' for ' + results.items.length + ' match' + (results.items.length === 1 ? '' : 'es') + ')');
+  const target = results.items[idx];
+  const loc = p.after ? Word.InsertLocation.after : Word.InsertLocation.before;
+  const inserted = target.insertText(p.text, loc);
+  inserted.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.getSelection = () => Word.run(async (ctx) => {
+  const sel = ctx.document.getSelection();
+  sel.load('text,style');
+  await ctx.sync();
+  return { text: sel.text, style: sel.style };
+});
+
+commands.replaceSelection = (p) => Word.run(async (ctx) => {
+  const sel = ctx.document.getSelection();
+  const inserted = sel.insertText(p.text, Word.InsertLocation.replace);
+  inserted.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == FORMATTING ==
+commands.formatRange = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.text, { matchCase: p.matchCase || false });
+  results.load('font');
+  await ctx.sync();
+  if (results.items.length === 0) throw new Error('Text not found: ' + p.text);
+  const idx = p.occurrence || 0;
+  if (idx >= results.items.length) throw new Error('Occurrence ' + idx + ' not found (only ' + results.items.length + ' match' + (results.items.length === 1 ? '' : 'es') + ')');
+  const target = results.items[idx];
+  const font = target.font;
+  if (p.bold !== undefined) font.bold = p.bold;
+  if (p.italic !== undefined) font.italic = p.italic;
+  if (p.underline !== undefined) font.underline = p.underline ? 'Single' : 'None';
+  if (p.strikeThrough !== undefined) font.strikeThrough = p.strikeThrough;
+  if (p.color) font.color = p.color;
+  if (p.highlightColor) font.highlightColor = p.highlightColor;
+  if (p.size) font.size = p.size;
+  if (p.name) font.name = p.name;
+  target.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == TABLES ==
+commands.insertTable = (p) => Word.run(async (ctx) => {
+  const body = ctx.document.body;
+  const table = body.insertTable(p.rows, p.cols, p.location || 'End', p.data || null);
+  if (p.style) table.style = p.style;
+  table.headerRowCount = p.headerRowCount || 1;
+  await ctx.sync();
+  // Move cursor after the table
+  const tableRange = table.getRange('End');
+  tableRange.select();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.getTables = () => Word.run(async (ctx) => {
+  const tables = ctx.document.body.tables;
+  tables.load('rowCount,values,style,headerRowCount');
+  await ctx.sync();
+  const items = tables.items.map((t, i) => ({
+    index: i, rowCount: t.rowCount, style: t.style, headerRowCount: t.headerRowCount,
+    values: t.values
+  }));
+  return { count: items.length, tables: items };
+});
+
+commands.getTableData = (p) => Word.run(async (ctx) => {
+  const tables = ctx.document.body.tables;
+  tables.load('rowCount,values');
+  await ctx.sync();
+  if (p.index >= tables.items.length) throw new Error('Table index out of range. Document has ' + tables.items.length + ' table(s).');
+  return { values: tables.items[p.index].values };
+});
+
+commands.setTableCell = (p) => Word.run(async (ctx) => {
+  const tables = ctx.document.body.tables;
+  tables.load('rowCount');
+  await ctx.sync();
+  if (p.tableIndex >= tables.items.length) throw new Error('Table index out of range. Document has ' + tables.items.length + ' table(s).');
+  const table = tables.items[p.tableIndex];
+  try {
+    const cell = table.getCell(p.row, p.col);
+    cell.body.clear();
+    const inserted = cell.body.insertText(p.text, Word.InsertLocation.start);
+    inserted.getRange('End').select();
+    await ctx.sync();
+  } catch (e) {
+    if (e.message && e.message.includes('ItemNotFound')) {
+      throw new Error('Cell not found at row ' + p.row + ', col ' + p.col + '. Table has ' + table.rowCount + ' rows. Use word_get_table_data to inspect the table.');
+    }
+    throw e;
+  }
+  return { success: true };
+});
+
+commands.addTableRow = (p) => Word.run(async (ctx) => {
+  const tables = ctx.document.body.tables;
+  tables.load('rowCount');
+  await ctx.sync();
+  if (p.tableIndex >= tables.items.length) throw new Error('Table index out of range');
+  const table = tables.items[p.tableIndex];
+  table.addRows(p.location || 'End', 1, p.values ? [p.values] : undefined);
+  await ctx.sync();
+  // Move cursor to end of table after adding row
+  const tableRange = table.getRange('End');
+  tableRange.select();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.deleteTableRow = (p) => Word.run(async (ctx) => {
+  const tables = ctx.document.body.tables;
+  tables.load('rowCount');
+  await ctx.sync();
+  if (p.tableIndex >= tables.items.length) throw new Error('Table index out of range. Document has ' + tables.items.length + ' table(s).');
+  const rows = tables.items[p.tableIndex].rows;
+  rows.load('items');
+  await ctx.sync();
+  if (p.rowIndex >= rows.items.length) throw new Error('Row index out of range. Table has ' + rows.items.length + ' rows (0-indexed).');
+  rows.items[p.rowIndex].delete();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == LISTS ==
+commands.insertList = (p) => Word.run(async (ctx) => {
+  if (!p.items || p.items.length === 0) throw new Error('items array must not be empty');
+  const body = ctx.document.body;
+  // Check if last paragraph is a list item — if so, insert a non-list separator
+  const lastPara = body.paragraphs.getLast();
+  lastPara.load('isListItem');
+  await ctx.sync();
+  if (lastPara.isListItem && (p.location || 'End') === 'End') {
+    const sep = body.insertParagraph('', 'End');
+    sep.style = 'Normal';
+    sep.detachFromList();
+    await ctx.sync();
+  }
+  const para = body.insertParagraph(p.items[0], p.location || 'End');
+  para.style = 'Normal';
+  await ctx.sync();
+  const list = para.startNewList();
+  for (let i = 1; i < p.items.length; i++) {
+    list.insertParagraph(p.items[i], Word.InsertLocation.end);
+  }
+  if (p.numbered) {
+    list.setLevelNumbering(0, Word.ListNumbering.arabic);
+  } else {
+    list.setLevelBullet(0, Word.ListBullet.solid);
+  }
+  await ctx.sync();
+  // Move cursor to end of last list paragraph
+  const endPara = body.paragraphs.getLast();
+  endPara.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == COMMENTS ==
+commands.addComment = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.anchorText, { matchCase: p.matchCase || false });
+  results.load('text');
+  await ctx.sync();
+  if (results.items.length === 0) throw new Error('Anchor not found: ' + p.anchorText);
+  const idx = p.occurrence || 0;
+  if (idx >= results.items.length) throw new Error('Occurrence ' + idx + ' not found (only ' + results.items.length + ' match' + (results.items.length === 1 ? '' : 'es') + ')');
+  const target = results.items[idx];
+  target.insertComment(p.comment);
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.getComments = () => Word.run(async (ctx) => {
+  const comments = ctx.document.body.getComments();
+  comments.load('id,authorName,content,creationDate,resolved');
+  await ctx.sync();
+  const items = comments.items.map(c => ({ id: c.id, author: c.authorName, content: c.content, date: c.creationDate, resolved: c.resolved }));
+  return { count: items.length, comments: items };
+});
+
+commands.replyToComment = (p) => Word.run(async (ctx) => {
+  const comments = ctx.document.body.getComments();
+  comments.load('id');
+  await ctx.sync();
+  let target = null;
+  for (const c of comments.items) {
+    if (String(c.id) === String(p.commentId)) { target = c; break; }
+  }
+  if (!target) throw new Error('Comment not found: ' + p.commentId);
+  target.reply(p.text);
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.resolveComment = (p) => Word.run(async (ctx) => {
+  const comments = ctx.document.body.getComments();
+  comments.load('id');
+  await ctx.sync();
+  for (const c of comments.items) {
+    if (String(c.id) === String(p.commentId)) {
+      c.resolved = true;
+      await ctx.sync();
+      return { success: true };
+    }
+  }
+  throw new Error('Comment not found: ' + p.commentId);
+});
+
+commands.deleteComment = (p) => Word.run(async (ctx) => {
+  const comments = ctx.document.body.getComments();
+  comments.load('id');
+  await ctx.sync();
+  for (const c of comments.items) {
+    if (String(c.id) === String(p.commentId)) {
+      c.delete();
+      await ctx.sync();
+      return { success: true };
+    }
+  }
+  throw new Error('Comment not found: ' + p.commentId);
+});
+
+// == FOOTNOTES & ENDNOTES ==
+commands.insertFootnote = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.anchorText, { matchCase: p.matchCase || false });
+  results.load('text');
+  await ctx.sync();
+  if (results.items.length === 0) throw new Error('Anchor not found: ' + p.anchorText);
+  const idx = p.occurrence || 0;
+  if (idx >= results.items.length) throw new Error('Occurrence ' + idx + ' not found (only ' + results.items.length + ' match' + (results.items.length === 1 ? '' : 'es') + ')');
+  const target = results.items[idx];
+  target.insertFootnote(p.text);
+  target.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.insertEndnote = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.anchorText, { matchCase: p.matchCase || false });
+  results.load('text');
+  await ctx.sync();
+  if (results.items.length === 0) throw new Error('Anchor not found: ' + p.anchorText);
+  const idx = p.occurrence || 0;
+  if (idx >= results.items.length) throw new Error('Occurrence ' + idx + ' not found (only ' + results.items.length + ' match' + (results.items.length === 1 ? '' : 'es') + ')');
+  const target = results.items[idx];
+  target.insertEndnote(p.text);
+  target.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.getFootnotes = () => Word.run(async (ctx) => {
+  const footnotes = ctx.document.body.footnotes;
+  footnotes.load('items');
+  await ctx.sync();
+  const items = [];
+  for (const fn of footnotes.items) {
+    fn.body.load('text');
+    await ctx.sync();
+    items.push({ index: items.length, text: fn.body.text.replace(/^\u0002\s*/, '') });
+  }
+  return { count: items.length, footnotes: items };
+});
+
+commands.getEndnotes = () => Word.run(async (ctx) => {
+  const endnotes = ctx.document.body.endnotes;
+  endnotes.load('items');
+  await ctx.sync();
+  const items = [];
+  for (const en of endnotes.items) {
+    en.body.load('text');
+    await ctx.sync();
+    items.push({ index: items.length, text: en.body.text.replace(/^\u0002\s*/, '') });
+  }
+  return { count: items.length, endnotes: items };
+});
+
+// == TRACK CHANGES ==
+commands.getTrackedChanges = () => Word.run(async (ctx) => {
+  const changes = ctx.document.body.getTrackedChanges();
+  changes.load('type,author,date,text');
+  await ctx.sync();
+  const items = changes.items.map((c, i) => ({ index: i, type: c.type, author: c.author, date: c.date, text: c.text }));
+  return { count: items.length, changes: items };
+});
+
+commands.acceptTrackedChange = (p) => Word.run(async (ctx) => {
+  const changes = ctx.document.body.getTrackedChanges();
+  changes.load('items');
+  await ctx.sync();
+  if (p.index >= changes.items.length) throw new Error('Change index out of range. Document has ' + changes.items.length + ' tracked change(s).');
+  changes.items[p.index].accept();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.rejectTrackedChange = (p) => Word.run(async (ctx) => {
+  const changes = ctx.document.body.getTrackedChanges();
+  changes.load('items');
+  await ctx.sync();
+  if (p.index >= changes.items.length) throw new Error('Change index out of range. Document has ' + changes.items.length + ' tracked change(s).');
+  changes.items[p.index].reject();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.acceptAllTrackedChanges = () => Word.run(async (ctx) => {
+  const changes = ctx.document.body.getTrackedChanges();
+  changes.load('items');
+  await ctx.sync();
+  changes.acceptAll();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.rejectAllTrackedChanges = () => Word.run(async (ctx) => {
+  const changes = ctx.document.body.getTrackedChanges();
+  changes.load('items');
+  await ctx.sync();
+  changes.rejectAll();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == CONTENT CONTROLS ==
+commands.getContentControls = () => Word.run(async (ctx) => {
+  // Use getContentControls with types filter (WordApi 1.5+) to include PlainText and CheckBox
+  const ccs = ctx.document.body.getContentControls({ types: [Word.ContentControlType.richText, Word.ContentControlType.plainText, Word.ContentControlType.checkBox] });
+  ccs.load('id,tag,title,type,text');
+  await ctx.sync();
+  return { count: ccs.items.length, controls: ccs.items.map(c => ({ id: c.id, tag: c.tag, title: c.title, type: c.type, text: c.text })) };
+});
+
+commands.setContentControlText = (p) => Word.run(async (ctx) => {
+  let target = null;
+  if (p.tag) {
+    // Include CheckBox in query so we can give a proper error instead of "not found"
+    const ccs = ctx.document.body.getContentControls({ types: [Word.ContentControlType.richText, Word.ContentControlType.plainText, Word.ContentControlType.checkBox] });
+    ccs.load('id,tag,type');
+    await ctx.sync();
+    for (const cc of ccs.items) {
+      if (cc.tag === p.tag) {
+        if (cc.type === 'CheckBox') {
+          throw new Error('Cannot set text on a CheckBox content control. CheckBox controls only support checked/unchecked state.');
+        }
+        target = cc;
+        break;
+      }
+    }
+  }
+  if (!target && p.id) {
+    // Search all types to give a better error for CheckBox
+    const allCcs = ctx.document.body.getContentControls({ types: [Word.ContentControlType.richText, Word.ContentControlType.plainText, Word.ContentControlType.checkBox] });
+    allCcs.load('id,type');
+    await ctx.sync();
+    for (const cc of allCcs.items) {
+      if (cc.id === p.id) {
+        if (cc.type === 'CheckBox') {
+          throw new Error('Cannot set text on a CheckBox content control. CheckBox controls only support checked/unchecked state.');
+        }
+        target = cc;
+        break;
+      }
+    }
+  }
+  if (!target) throw new Error('Content control not found. Use word_get_content_controls to list available controls.');
+  const inserted = target.insertText(p.text, Word.InsertLocation.replace);
+  inserted.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == HEADERS & FOOTERS ==
+commands.getHeaderFooter = (p) => Word.run(async (ctx) => {
+  const sections = ctx.document.sections;
+  sections.load('items');
+  await ctx.sync();
+  const section = sections.items[p.sectionIndex || 0];
+  const target = p.type === 'footer' ? section.getFooter(p.headerType || 'Primary') : section.getHeader(p.headerType || 'Primary');
+  target.load('text');
+  await ctx.sync();
+  return { text: target.text };
+});
+
+commands.setHeaderFooter = (p) => Word.run(async (ctx) => {
+  const sections = ctx.document.sections;
+  sections.load('items');
+  await ctx.sync();
+  const section = sections.items[p.sectionIndex || 0];
+  const target = p.type === 'footer' ? section.getFooter(p.headerType || 'Primary') : section.getHeader(p.headerType || 'Primary');
+  target.clear();
+  target.insertText(p.text, Word.InsertLocation.start);
+  await ctx.sync();
+  return { success: true };
+});
+
+// == IMAGES ==
+commands.insertImage = (p) => Word.run(async (ctx) => {
+  const body = ctx.document.body;
+  const picture = body.insertInlinePictureFromBase64(p.base64, p.location || 'End');
+  if (p.width) picture.width = p.width;
+  if (p.height) picture.height = p.height;
+  if (p.altText) picture.altTextDescription = p.altText;
+  try {
+    await ctx.sync();
+  } catch (e) {
+    if (e.message && e.message.includes('GeneralException')) {
+      throw new Error('Invalid image data. Ensure the base64 string is a valid PNG, JPEG, or GIF image.');
+    }
+    throw e;
+  }
+  // Move cursor after the image
+  const imgRange = picture.getRange('End');
+  imgRange.select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == BOOKMARKS ==
+commands.getBookmarks = () => Word.run(async (ctx) => {
+  // getBookmarks is available on Range objects (WordApi 1.4+)
+  const range = ctx.document.body.getRange();
+  try {
+    const bookmarks = range.getBookmarks(true, true);
+    await ctx.sync();
+    return { bookmarks: bookmarks.value };
+  } catch (e) {
+    // Fallback: if getBookmarks is not available on this platform,
+    // try the body-level method
+    try {
+      const bookmarks = ctx.document.body.getBookmarks(true);
+      await ctx.sync();
+      return { bookmarks: bookmarks.value };
+    } catch (e2) {
+      throw new Error('getBookmarks is not supported on this Word platform version. Bookmarks can still be inserted and deleted by name.');
+    }
+  }
+});
+
+commands.insertBookmark = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.anchorText, { matchCase: p.matchCase || false });
+  results.load('text');
+  await ctx.sync();
+  if (results.items.length === 0) throw new Error('Anchor not found: ' + p.anchorText);
+  const target = results.items[p.occurrence || 0];
+  target.insertBookmark(p.name);
+  target.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.deleteBookmark = (p) => Word.run(async (ctx) => {
+  // Verify bookmark exists before deleting
+  const range = ctx.document.body.getRange();
+  const bookmarks = range.getBookmarks(true, true);
+  await ctx.sync();
+  if (!bookmarks.value || !bookmarks.value.includes(p.name)) {
+    throw new Error('Bookmark not found: ' + p.name);
+  }
+  ctx.document.deleteBookmark(p.name);
+  await ctx.sync();
+  return { success: true };
+});
+
+// == STYLES ==
+commands.getStyles = () => Word.run(async (ctx) => {
+  const styles = ctx.document.getStyles();
+  styles.load('nameLocal,type,builtIn');
+  await ctx.sync();
+  const items = styles.items.map(s => ({ name: s.nameLocal, type: s.type, builtIn: s.builtIn }));
+  return { count: items.length, styles: items.slice(0, 80) };
+});
+
+// == COAUTHORING (Desktop only) ==
+commands.getCoauthors = () => Word.run(async (ctx) => {
+  const coauthoring = ctx.document.coauthoring;
+  coauthoring.load('canCoauthor,canMerge,pendingUpdates');
+  const authors = coauthoring.authors;
+  authors.load('name,email');
+  await ctx.sync();
+  const items = authors.items.map(a => ({ name: a.name, email: a.email }));
+  return { canCoauthor: coauthoring.canCoauthor, canMerge: coauthoring.canMerge, pendingUpdates: coauthoring.pendingUpdates, authors: items };
+});
+
+// == DOCUMENT OPERATIONS ==
+commands.saveDocument = () => Word.run(async (ctx) => {
+  ctx.document.save();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.getWordCount = () => Word.run(async (ctx) => {
+  const body = ctx.document.body;
+  body.load('text');
+  const paragraphs = body.paragraphs;
+  paragraphs.load('text');
+  await ctx.sync();
+  const text = body.text;
+  const words = text.split(/\s+/).filter(w => w.length > 0).length;
+  const chars = text.length;
+  const charsNoSpaces = text.replace(/\s/g, '').length;
+  return { words, characters: chars, charactersNoSpaces: charsNoSpaces, paragraphs: paragraphs.items.length };
+});
+
+// == PAGE & SECTION BREAKS ==
+commands.insertPageBreak = (p) => Word.run(async (ctx) => {
+  const body = ctx.document.body;
+  if (p.paragraphIndex !== undefined) {
+    if (p.paragraphIndex < 0) throw new Error('Index must be non-negative');
+    const paragraphs = body.paragraphs;
+    paragraphs.load('text');
+    await ctx.sync();
+    if (p.paragraphIndex >= paragraphs.items.length) throw new Error('Paragraph index out of range. Document has ' + paragraphs.items.length + ' paragraphs (0-indexed).');
+    const para = paragraphs.items[p.paragraphIndex];
+    para.insertBreak('Page', 'After');
+    para.getRange('End').select();
+  } else {
+    const lastPara = body.paragraphs.getLast();
+    lastPara.insertBreak('Page', 'After');
+    lastPara.getRange('End').select();
+  }
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.insertSectionBreak = (p) => Word.run(async (ctx) => {
+  const body = ctx.document.body;
+  const breakType = p.breakType || 'SectionNext';
+  if (p.paragraphIndex !== undefined) {
+    if (p.paragraphIndex < 0) throw new Error('Index must be non-negative');
+    const paragraphs = body.paragraphs;
+    paragraphs.load('text');
+    await ctx.sync();
+    if (p.paragraphIndex >= paragraphs.items.length) throw new Error('Paragraph index out of range. Document has ' + paragraphs.items.length + ' paragraphs (0-indexed).');
+    const para = paragraphs.items[p.paragraphIndex];
+    para.insertBreak(breakType, 'After');
+    para.getRange('End').select();
+    try {
+      await ctx.sync();
+    } catch (e) {
+      if (e.message && e.message.includes('GeneralException')) {
+        throw new Error('Cannot insert section break at paragraph ' + p.paragraphIndex + '. The paragraph may be inside a table cell (section/page breaks are not allowed inside tables).');
+      }
+      throw e;
+    }
+  } else {
+    const lastPara = body.paragraphs.getLast();
+    lastPara.insertBreak(breakType, 'After');
+    lastPara.getRange('End').select();
+    await ctx.sync();
+  }
+  return { success: true };
+});
+
+// == HYPERLINKS ==
+commands.insertHyperlink = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.anchorText, { matchCase: p.matchCase || false });
+  results.load('text');
+  await ctx.sync();
+  if (results.items.length === 0) throw new Error('Anchor not found: ' + p.anchorText);
+  const target = results.items[p.occurrence || 0];
+  target.hyperlink = p.url;
+  target.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == FIELDS ==
+commands.getFields = () => Word.run(async (ctx) => {
+  const fields = ctx.document.body.fields;
+  fields.load('code,result,type');
+  await ctx.sync();
+  const items = fields.items.map((f, i) => ({ index: i, code: (f.code || '').replace(/[\u0001\u0013\u0014\u0015]/g, '').trim(), result: f.result, type: f.type }));
+  return { count: items.length, fields: items };
+});
+
+// == CONTENT CONTROL INSERTION ==
+commands.insertContentControl = (p) => Word.run(async (ctx) => {
+  const ccType = p.type || 'RichText';
+  let range;
+  if (p.anchorText) {
+    const results = ctx.document.body.search(p.anchorText, { matchCase: p.matchCase || false });
+    results.load('text');
+    await ctx.sync();
+    if (results.items.length === 0) throw new Error('Anchor not found: ' + p.anchorText);
+    range = results.items[p.occurrence || 0];
+  } else {
+    range = ctx.document.getSelection();
+  }
+  const cc = range.insertContentControl(ccType);
+  if (p.title) cc.title = p.title;
+  if (p.tag) cc.tag = p.tag;
+  if (p.color) cc.color = p.color;
+  cc.getRange('End').select();
+  await ctx.sync();
+  const result = { success: true };
+  if (ccType === 'CheckBox') {
+    result.warning = 'CheckBox content controls replace the anchor text with a checkbox widget. The original text is not preserved.';
+  }
+  return result;
+});
+
+// == PAGE LAYOUT ==
+commands.setPageLayout = (p) => Word.run(async (ctx) => {
+  const sections = ctx.document.sections;
+  sections.load('items');
+  await ctx.sync();
+  const section = sections.items[p.sectionIndex || 0];
+  const pageSetup = section.pageSetup;
+  if (p.orientation) pageSetup.orientation = p.orientation; // 'Portrait' or 'Landscape'
+  if (p.topMargin !== undefined) pageSetup.topMargin = p.topMargin;
+  if (p.bottomMargin !== undefined) pageSetup.bottomMargin = p.bottomMargin;
+  if (p.leftMargin !== undefined) pageSetup.leftMargin = p.leftMargin;
+  if (p.rightMargin !== undefined) pageSetup.rightMargin = p.rightMargin;
+  if (p.paperSize) pageSetup.paperSize = p.paperSize; // 'Letter', 'A4', etc.
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.getPageLayout = (p) => Word.run(async (ctx) => {
+  const sections = ctx.document.sections;
+  sections.load('items');
+  await ctx.sync();
+  const section = sections.items[p.sectionIndex || 0];
+  const ps = section.pageSetup;
+  ps.load('orientation,topMargin,bottomMargin,leftMargin,rightMargin,paperSize,headerDistance,footerDistance');
+  await ctx.sync();
+  return { orientation: ps.orientation, topMargin: ps.topMargin, bottomMargin: ps.bottomMargin, leftMargin: ps.leftMargin, rightMargin: ps.rightMargin, paperSize: ps.paperSize, headerDistance: ps.headerDistance, footerDistance: ps.footerDistance };
+});
+
+// == FONT INFO ==
+commands.getFontInfo = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.text, { matchCase: p.matchCase || false });
+  results.load('font');
+  await ctx.sync();
+  if (results.items.length === 0) throw new Error('Text not found: ' + p.text);
+  const idx = p.occurrence || 0;
+  if (idx >= results.items.length) throw new Error('Occurrence ' + idx + ' not found (only ' + results.items.length + ' match' + (results.items.length === 1 ? '' : 'es') + ')');
+  const target = results.items[idx];
+  const font = target.font;
+  font.load('name,size,bold,italic,underline,strikeThrough,color,highlightColor');
+  await ctx.sync();
+  return { name: font.name, size: font.size, bold: font.bold, italic: font.italic, underline: font.underline, strikeThrough: font.strikeThrough, color: font.color, highlightColor: font.highlightColor };
+});
+
+// == CUSTOM PROPERTIES ==
+commands.getCustomProperties = () => Word.run(async (ctx) => {
+  const customProps = ctx.document.properties.customProperties;
+  customProps.load('key,value,type');
+  await ctx.sync();
+  const items = customProps.items.map(p => ({ key: p.key, value: p.value, type: p.type }));
+  return { count: items.length, properties: items };
+});
+
+commands.setCustomProperty = (p) => Word.run(async (ctx) => {
+  ctx.document.properties.customProperties.add(p.key, p.value);
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.deleteCustomProperty = (p) => Word.run(async (ctx) => {
+  const customProps = ctx.document.properties.customProperties;
+  customProps.load('key');
+  await ctx.sync();
+  for (const cp of customProps.items) {
+    if (cp.key === p.key) { cp.delete(); await ctx.sync(); return { success: true }; }
+  }
+  throw new Error('Custom property not found: ' + p.key);
+});
+
+// == ADVANCED TEXT INSERTION ==
+commands.insertHtml = (p) => Word.run(async (ctx) => {
+  const body = ctx.document.body;
+  const loc = p.location || 'End';
+  const range = body.insertHtml(p.html, loc);
+  range.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.insertOoxml = (p) => Word.run(async (ctx) => {
+  const body = ctx.document.body;
+  const range = body.insertOoxml(p.ooxml, p.location || 'End');
+  range.getRange('End').select();
+  try {
+    await ctx.sync();
+  } catch (e) {
+    if (e.message && e.message.includes('GeneralException')) {
+      throw new Error('Invalid OOXML. Ensure the XML follows the Office Open XML package structure (pkg:package with word/document.xml part).');
+    }
+    throw e;
+  }
+  return { success: true };
+});
+
+// == PARAGRAPH DETAILS & SPACING ==
+commands.getParagraphByIndex = (p) => Word.run(async (ctx) => {
+  if (p.index < 0) throw new Error('Index must be non-negative');
+  const paragraphs = ctx.document.body.paragraphs;
+  paragraphs.load('text');
+  await ctx.sync();
+  if (p.index >= paragraphs.items.length) throw new Error('Paragraph index out of range. Document has ' + paragraphs.items.length + ' paragraphs (0-indexed).');
+  const para = paragraphs.items[p.index];
+  para.load('text,style,alignment,firstLineIndent,leftIndent,rightIndent,lineSpacing,spaceBefore,spaceAfter,outlineLevel,isListItem');
+  para.font.load('name,size,bold,italic,color,underline');
+  await ctx.sync();
+  return { text: para.text, style: para.style, alignment: para.alignment, firstLineIndent: para.firstLineIndent, leftIndent: para.leftIndent, rightIndent: para.rightIndent, lineSpacing: para.lineSpacing, spaceBefore: para.spaceBefore, spaceAfter: para.spaceAfter, outlineLevel: para.outlineLevel, isListItem: para.isListItem, font: { name: para.font.name, size: para.font.size, bold: para.font.bold, italic: para.font.italic, color: para.font.color, underline: para.font.underline } };
+});
+
+commands.setParagraphSpacing = (p) => Word.run(async (ctx) => {
+  if (p.index < 0) throw new Error('Index must be non-negative');
+  if (p.lineSpacing !== undefined && p.lineSpacing <= 0) throw new Error('lineSpacing must be positive (e.g. 12, 15, 18)');
+  if (p.spaceBefore !== undefined && p.spaceBefore < 0) throw new Error('spaceBefore must be non-negative');
+  if (p.spaceAfter !== undefined && p.spaceAfter < 0) throw new Error('spaceAfter must be non-negative');
+  const paragraphs = ctx.document.body.paragraphs;
+  paragraphs.load('text');
+  await ctx.sync();
+  if (p.index >= paragraphs.items.length) throw new Error('Paragraph index out of range. Document has ' + paragraphs.items.length + ' paragraphs (0-indexed).');
+  const para = paragraphs.items[p.index];
+  if (p.lineSpacing !== undefined) para.lineSpacing = p.lineSpacing;
+  if (p.spaceBefore !== undefined) para.spaceBefore = p.spaceBefore;
+  if (p.spaceAfter !== undefined) para.spaceAfter = p.spaceAfter;
+  if (p.firstLineIndent !== undefined) para.firstLineIndent = p.firstLineIndent;
+  if (p.leftIndent !== undefined) para.leftIndent = p.leftIndent;
+  if (p.rightIndent !== undefined) para.rightIndent = p.rightIndent;
+  para.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == BOOKMARK NAVIGATION ==
+commands.goToBookmark = (p) => Word.run(async (ctx) => {
+  const range = ctx.document.getBookmarkRange(p.name);
+  range.load('text');
+  range.select();
+  await ctx.sync();
+  return { success: true, text: range.text };
+});
+
+commands.getBookmarkText = (p) => Word.run(async (ctx) => {
+  const range = ctx.document.getBookmarkRange(p.name);
+  range.load('text');
+  await ctx.sync();
+  return { text: range.text };
+});
+
+// == SECTIONS ==
+commands.getSections = () => Word.run(async (ctx) => {
+  const sections = ctx.document.sections;
+  sections.load('items');
+  await ctx.sync();
+  const items = [];
+  for (let i = 0; i < sections.items.length; i++) {
+    const ps = sections.items[i].pageSetup;
+    ps.load('orientation,topMargin,bottomMargin,leftMargin,rightMargin,paperSize');
+    await ctx.sync();
+    items.push({ index: i, orientation: ps.orientation, topMargin: ps.topMargin, bottomMargin: ps.bottomMargin, leftMargin: ps.leftMargin, rightMargin: ps.rightMargin, paperSize: ps.paperSize });
+  }
+  return { count: items.length, sections: items };
+});
+
+// == TABLE ADVANCED ==
+commands.mergeTableCells = (p) => Word.run(async (ctx) => {
+  const tables = ctx.document.body.tables;
+  tables.load('rowCount');
+  await ctx.sync();
+  if (p.tableIndex >= tables.items.length) throw new Error('Table index out of range');
+  tables.items[p.tableIndex].mergeCells(p.topRow, p.firstCell, p.bottomRow, p.lastCell);
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.splitTableCell = (p) => Word.run(async (ctx) => {
+  const tables = ctx.document.body.tables;
+  tables.load('rowCount');
+  await ctx.sync();
+  if (p.tableIndex >= tables.items.length) throw new Error('Table index out of range');
+  const cell = tables.items[p.tableIndex].getCell(p.row, p.col);
+  cell.split(p.rowCount || 1, p.colCount || 2);
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.setTableStyle = (p) => Word.run(async (ctx) => {
+  const tables = ctx.document.body.tables;
+  tables.load('rowCount');
+  await ctx.sync();
+  if (p.tableIndex >= tables.items.length) throw new Error('Table index out of range');
+  tables.items[p.tableIndex].style = p.style;
+  await ctx.sync();
+  return { success: true };
+});
+
+// == COMMENT REPLIES ==
+commands.getCommentReplies = (p) => Word.run(async (ctx) => {
+  const comments = ctx.document.body.getComments();
+  comments.load('id,replies');
+  await ctx.sync();
+  for (const c of comments.items) {
+    if (String(c.id) === String(p.commentId)) {
+      const replies = c.replies;
+      replies.load('authorName,content,creationDate');
+      await ctx.sync();
+      const items = replies.items.map(r => ({ author: r.authorName, content: r.content, date: r.creationDate }));
+      return { count: items.length, replies: items };
+    }
+  }
+  throw new Error('Comment not found: ' + p.commentId);
+});
+
+// == CHANGE TRACKING MODE ==
+commands.getChangeTrackingMode = () => Word.run(async (ctx) => {
+  const doc = ctx.document;
+  doc.load('changeTrackingMode');
+  await ctx.sync();
+  return { mode: doc.changeTrackingMode };
+});
+
+// == CLEAR FORMATTING ==
+commands.clearFormatting = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.text, { matchCase: p.matchCase || false });
+  results.load('font,style');
+  await ctx.sync();
+  if (results.items.length === 0) throw new Error('Text not found: ' + p.text);
+  const idx = p.occurrence || 0;
+  if (idx >= results.items.length) throw new Error('Occurrence ' + idx + ' not found (only ' + results.items.length + ' match' + (results.items.length === 1 ? '' : 'es') + ')');
+  const target = results.items[idx];
+  // Get the style's default font to restore size and name
+  const styleName = target.style || 'Normal';
+  const styleObj = ctx.document.getStyles().getByNameOrNullObject(styleName);
+  styleObj.load('font/size,font/name');
+  await ctx.sync();
+  const font = target.font;
+  font.bold = false;
+  font.italic = false;
+  font.underline = 'None';
+  font.strikeThrough = false;
+  font.color = '#000000';
+  if (!styleObj.isNullObject) {
+    if (styleObj.font.size) font.size = styleObj.font.size;
+    if (styleObj.font.name) font.name = styleObj.font.name;
+  }
+  target.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == INSERT TOC ==
+commands.insertTableOfContents = (p) => Word.run(async (ctx) => {
+  const body = ctx.document.body;
+  // Insert a TOC field at the specified location
+  const range = body.getRange(p.location || 'Start');
+  range.insertField(p.location || 'Start', 'TOC', p.switches || '\\o "1-3" \\h \\z \\u', true);
+  await ctx.sync();
+  return { success: true };
+});
+
+// == SELECTION OPERATIONS ==
+commands.getSelectionInfo = () => Word.run(async (ctx) => {
+  const sel = ctx.document.getSelection();
+  sel.load('text,style,isEmpty');
+  sel.font.load('name,size,bold,italic,color,underline,strikeThrough,highlightColor');
+  await ctx.sync();
+  return { text: sel.text, style: sel.style, isEmpty: sel.isEmpty, font: { name: sel.font.name, size: sel.font.size, bold: sel.font.bold, italic: sel.font.italic, color: sel.font.color, underline: sel.font.underline, strikeThrough: sel.font.strikeThrough, highlightColor: sel.font.highlightColor } };
+});
+
+commands.insertTextAtSelection = (p) => Word.run(async (ctx) => {
+  const sel = ctx.document.getSelection();
+  const loc = p.replace ? Word.InsertLocation.replace : Word.InsertLocation.end;
+  const inserted = sel.insertText(p.text, loc);
+  inserted.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == IMAGES ==
+commands.getImages = () => Word.run(async (ctx) => {
+  const pics = ctx.document.body.inlinePictures;
+  pics.load('altTextDescription,altTextTitle,width,height,hyperlink');
+  await ctx.sync();
+  const items = pics.items.map((p, i) => ({ index: i, width: p.width, height: p.height, altText: p.altTextDescription, altTitle: p.altTextTitle, hyperlink: p.hyperlink }));
+  return { count: items.length, images: items };
+});
+
+commands.deleteImage = (p) => Word.run(async (ctx) => {
+  const pics = ctx.document.body.inlinePictures;
+  pics.load('altTextDescription');
+  await ctx.sync();
+  if (p.index >= pics.items.length) throw new Error('Image index out of range. Document has ' + pics.items.length + ' image(s) (0-indexed).');
+  pics.items[p.index].delete();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == TABLE CELL SHADING ==
+commands.setTableCellShading = (p) => Word.run(async (ctx) => {
+  const tables = ctx.document.body.tables;
+  tables.load('rowCount');
+  await ctx.sync();
+  if (p.tableIndex >= tables.items.length) throw new Error('Table index out of range');
+  const cell = tables.items[p.tableIndex].getCell(p.row, p.col);
+  cell.shadingColor = p.color;
+  cell.body.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == HYPERLINKS ==
+commands.getHyperlinks = () => Word.run(async (ctx) => {
+  const body = ctx.document.body;
+  const fields = body.fields;
+  fields.load('code,type');
+  await ctx.sync();
+  const links = [];
+  for (let i = 0; i < fields.items.length; i++) {
+    if (fields.items[i].type === 'Hyperlink') {
+      const code = (fields.items[i].code || '').replace(/[\u0001\u0013\u0014\u0015]/g, '').trim();
+      // Parse URL from field code
+      const match = code.match(/HYPERLINK\s+"([^"]+)"/);
+      const url = match ? match[1] : '';
+      // Skip internal TOC/bookmark links (start with \l)
+      const isInternal = /HYPERLINK\s+\\l\s+/.test(code);
+      fields.items[i].result.load('text');
+      await ctx.sync();
+      // Strip control characters from display text (TOC entries contain embedded PAGEREF fields)
+      const rawText = fields.items[i].result.text || '';
+      const cleanText = rawText.replace(/[\u0001\u0002\u0013\u0014\u0015]/g, '').replace(/\s{2,}/g, ' ').trim();
+      links.push({ index: i, url: url, text: cleanText, internal: isInternal });
+    }
+  }
+  return { count: links.length, hyperlinks: links };
+});
+
+commands.removeHyperlink = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.anchorText, { matchCase: p.matchCase || false });
+  results.load('hyperlink');
+  await ctx.sync();
+  if (results.items.length === 0) throw new Error('Text not found: ' + p.anchorText);
+  const target = results.items[p.occurrence || 0];
+  target.hyperlink = '';
+  target.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == FOOTNOTE/ENDNOTE MANAGEMENT ==
+commands.insertFootnoteAtIndex = (p) => Word.run(async (ctx) => {
+  const paragraphs = ctx.document.body.paragraphs;
+  paragraphs.load('text');
+  await ctx.sync();
+  if (p.paragraphIndex >= paragraphs.items.length) throw new Error('Paragraph index out of range. Document has ' + paragraphs.items.length + ' paragraphs (0-indexed).');
+  const para = paragraphs.items[p.paragraphIndex];
+  const range = para.getRange('End');
+  range.insertFootnote(p.text);
+  range.select();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.deleteFootnote = (p) => Word.run(async (ctx) => {
+  const footnotes = ctx.document.body.footnotes;
+  footnotes.load('items');
+  await ctx.sync();
+  if (p.index >= footnotes.items.length) throw new Error('Footnote index out of range. Document has ' + footnotes.items.length + ' footnote(s) (0-indexed).');
+  footnotes.items[p.index].delete();
+  await ctx.sync();
+  return { success: true };
+});
+
+commands.deleteEndnote = (p) => Word.run(async (ctx) => {
+  const endnotes = ctx.document.body.endnotes;
+  endnotes.load('items');
+  await ctx.sync();
+  if (p.index >= endnotes.items.length) throw new Error('Endnote index out of range. Document has ' + endnotes.items.length + ' endnote(s) (0-indexed).');
+  endnotes.items[p.index].delete();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == LIST OPERATIONS ==
+commands.getListInfo = (p) => Word.run(async (ctx) => {
+  const paragraphs = ctx.document.body.paragraphs;
+  paragraphs.load('text,isListItem');
+  await ctx.sync();
+  if (p.index >= paragraphs.items.length) throw new Error('Paragraph index out of range. Document has ' + paragraphs.items.length + ' paragraphs (0-indexed).');
+  const para = paragraphs.items[p.index];
+  if (!para.isListItem) return { isListItem: false };
+  para.load('listItem');
+  await ctx.sync();
+  const li = para.listItem;
+  li.load('level,listString,siblingIndex');
+  await ctx.sync();
+  return { isListItem: true, level: li.level, listString: li.listString, siblingIndex: li.siblingIndex };
+});
+
+commands.setListLevel = (p) => Word.run(async (ctx) => {
+  if (p.index < 0) throw new Error('Index must be non-negative');
+  const paragraphs = ctx.document.body.paragraphs;
+  paragraphs.load('text,isListItem');
+  await ctx.sync();
+  if (p.index >= paragraphs.items.length) throw new Error('Paragraph index out of range. Document has ' + paragraphs.items.length + ' paragraphs (0-indexed).');
+  const para = paragraphs.items[p.index];
+  if (!para.isListItem) throw new Error('Paragraph is not a list item');
+  para.load('listItem');
+  await ctx.sync();
+  para.listItem.level = p.level;
+  para.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});
+
+// == LINE BREAK ==
+commands.insertLineBreak = (p) => Word.run(async (ctx) => {
+  const results = ctx.document.body.search(p.anchorText, { matchCase: p.matchCase || false });
+  results.load('text');
+  await ctx.sync();
+  if (results.items.length === 0) throw new Error('Anchor not found: ' + p.anchorText);
+  const target = results.items[p.occurrence || 0];
+  const loc = p.before ? Word.InsertLocation.before : Word.InsertLocation.after;
+  target.insertBreak('Line', loc);
+  target.getRange('End').select();
+  await ctx.sync();
+  return { success: true };
+});