pptx-viewer-mcp 1.1.0

package/dist/mcp/index.js

@@ -0,0 +1,2339 @@
+#!/usr/bin/env node
+'use strict';
+
+var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
+var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
+var zod = require('zod');
+var pptxViewerCore = require('pptx-viewer-core');
+var promises = require('fs/promises');
+
+var GetSlideSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index")
+});
+var AddSlideSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  insertAfterIndex: zod.z.number().int().min(0).optional().describe("Insert after this slide index"),
+  backgroundColor: zod.z.string().optional().describe("Background color (hex)")
+});
+var DeleteSlidesSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndexes: zod.z.array(zod.z.number().int().min(0)).min(1).describe("Slide indexes to delete")
+});
+var ReorderSlidesSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  newOrder: zod.z.array(zod.z.number().int().min(0)).min(1).describe("New slide order as array of indexes")
+});
+var DuplicateSlideSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Slide to duplicate"),
+  targetIndex: zod.z.number().int().min(0).optional().describe("Where to insert the duplicate")
+});
+var UpdateSlidePropertiesSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  backgroundColor: zod.z.string().optional().describe("Background color (hex)"),
+  backgroundGradient: zod.z.string().optional().describe("Background gradient CSS"),
+  backgroundImage: zod.z.string().optional().describe("Background image data URL"),
+  notes: zod.z.string().optional().describe("Speaker notes text"),
+  hidden: zod.z.boolean().optional().describe("Whether slide is hidden")
+});
+var SetSlideTransitionSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  type: zod.z.string().describe('Transition type (e.g. "fade", "wipe", "none")'),
+  durationMs: zod.z.number().int().min(0).optional().describe("Duration in ms"),
+  direction: zod.z.string().optional().describe('Direction (e.g. "left", "right")'),
+  advanceOnClick: zod.z.boolean().optional().describe("Advance on mouse click"),
+  advanceAfterMs: zod.z.number().int().min(0).optional().describe("Auto-advance after ms")
+});
+var SetCanvasSizeSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  width: zod.z.number().positive().describe("Canvas width in points"),
+  height: zod.z.number().positive().describe("Canvas height in points")
+});
+var ConvertToMarkdownSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  outputDir: zod.z.string().optional().describe("Output directory for markdown and media"),
+  mediaFolderName: zod.z.string().optional().describe("Name for extracted media folder"),
+  includeMetadata: zod.z.boolean().optional().describe("Include presentation metadata"),
+  slideRange: zod.z.object({
+    start: zod.z.number().int().min(0).optional(),
+    end: zod.z.number().int().min(0).optional()
+  }).optional().describe("Slide range to convert"),
+  includeSpeakerNotes: zod.z.boolean().optional().describe("Include speaker notes"),
+  semanticMode: zod.z.boolean().optional().describe("Use semantic (clean) markdown mode")
+});
+var AccessibilityCheckSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file")
+});
+var AddElementSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  type: zod.z.enum(["text", "shape", "image", "table", "connector"]).describe("Element type to add"),
+  x: zod.z.number().optional().describe("X position in points"),
+  y: zod.z.number().optional().describe("Y position in points"),
+  width: zod.z.number().optional().describe("Width in points"),
+  height: zod.z.number().optional().describe("Height in points"),
+  text: zod.z.string().optional().describe("Text content"),
+  fontSize: zod.z.number().optional().describe("Font size in points"),
+  fontFamily: zod.z.string().optional().describe("Font family name"),
+  fontColor: zod.z.string().optional().describe("Font color (hex)"),
+  bold: zod.z.boolean().optional().describe("Bold text"),
+  italic: zod.z.boolean().optional().describe("Italic text"),
+  underline: zod.z.boolean().optional().describe("Underline text"),
+  alignment: zod.z.enum(["left", "center", "right", "justify"]).optional().describe("Text alignment"),
+  shapeType: zod.z.string().optional().describe('Shape type (e.g. "rect", "ellipse")'),
+  fillColor: zod.z.string().optional().describe("Fill color (hex)"),
+  strokeColor: zod.z.string().optional().describe("Stroke color (hex)"),
+  strokeWidth: zod.z.number().optional().describe("Stroke width in points"),
+  imageData: zod.z.string().optional().describe("Image as base64 data URL"),
+  altText: zod.z.string().optional().describe("Alt text for accessibility"),
+  rows: zod.z.number().int().min(1).optional().describe("Number of table rows"),
+  columns: zod.z.number().int().min(1).optional().describe("Number of table columns"),
+  cellData: zod.z.array(zod.z.array(zod.z.string())).optional().describe("Table cell data as 2D array"),
+  headerRow: zod.z.boolean().optional().describe("Style first row as header"),
+  startArrow: zod.z.string().optional().describe("Start arrow type"),
+  endArrow: zod.z.string().optional().describe("End arrow type"),
+  startShapeId: zod.z.string().optional().describe("Connect start to shape ID"),
+  endShapeId: zod.z.string().optional().describe("Connect end to shape ID")
+});
+var UpdateElementSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  elementId: zod.z.string().describe("Element ID to update"),
+  x: zod.z.number().optional(),
+  y: zod.z.number().optional(),
+  width: zod.z.number().optional(),
+  height: zod.z.number().optional(),
+  rotation: zod.z.number().optional(),
+  text: zod.z.string().optional(),
+  fontSize: zod.z.number().optional(),
+  fontFamily: zod.z.string().optional(),
+  fontColor: zod.z.string().optional(),
+  bold: zod.z.boolean().optional(),
+  italic: zod.z.boolean().optional(),
+  underline: zod.z.boolean().optional(),
+  alignment: zod.z.enum(["left", "center", "right", "justify"]).optional(),
+  fillColor: zod.z.string().optional(),
+  strokeColor: zod.z.string().optional(),
+  strokeWidth: zod.z.number().optional(),
+  opacity: zod.z.number().min(0).max(1).optional(),
+  hidden: zod.z.boolean().optional(),
+  flipH: zod.z.boolean().optional(),
+  flipV: zod.z.boolean().optional()
+});
+var DeleteElementsSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0),
+  elementIds: zod.z.array(zod.z.string()).min(1).describe("Element IDs to delete")
+});
+var ArrangeElementsSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0),
+  action: zod.z.enum(["align", "reorderLayer"]),
+  elementIds: zod.z.array(zod.z.string()).optional().describe("Element IDs (for align)"),
+  alignment: zod.z.enum(["left", "right", "top", "bottom", "centerH", "centerV"]).optional(),
+  elementId: zod.z.string().optional().describe("Element ID (for reorderLayer)"),
+  layerAction: zod.z.enum(["bringForward", "sendBackward", "bringToFront", "sendToBack"]).optional()
+});
+var CloneElementSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0),
+  elementId: zod.z.string(),
+  targetSlideIndexes: zod.z.array(zod.z.number().int().min(0)).optional(),
+  offsetX: zod.z.number().optional(),
+  offsetY: zod.z.number().optional()
+});
+var SetElementAnimationSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0),
+  elementId: zod.z.string(),
+  entrance: zod.z.string().optional(),
+  exit: zod.z.string().optional(),
+  durationMs: zod.z.number().optional(),
+  delayMs: zod.z.number().optional(),
+  order: zod.z.number().optional()
+});
+var GroupElementsSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0),
+  elementIds: zod.z.array(zod.z.string()).min(2).describe("At least 2 element IDs to group")
+});
+var UngroupElementsSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0),
+  groupElementId: zod.z.string().describe("Group element ID to ungroup")
+});
+var BatchUpdateElementsSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0),
+  elementIds: zod.z.array(zod.z.string()).min(1),
+  x: zod.z.number().optional(),
+  y: zod.z.number().optional(),
+  width: zod.z.number().optional(),
+  height: zod.z.number().optional(),
+  rotation: zod.z.number().optional(),
+  opacity: zod.z.number().min(0).max(1).optional(),
+  hidden: zod.z.boolean().optional()
+});
+var UpdateTableCellsSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0),
+  elementId: zod.z.string().describe("Table element ID"),
+  cells: zod.z.array(
+    zod.z.object({
+      row: zod.z.number().int().min(0),
+      col: zod.z.number().int().min(0),
+      text: zod.z.string()
+    })
+  ).min(1).describe("Cells to update")
+});
+var ManageTableStructureSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0),
+  elementId: zod.z.string().describe("Table element ID"),
+  action: zod.z.enum(["insertRow", "deleteRow", "insertColumn", "deleteColumn"]),
+  position: zod.z.number().int().min(0).optional().describe("Insertion position index"),
+  referenceIndex: zod.z.number().int().min(0).optional(),
+  cellTexts: zod.z.array(zod.z.string()).optional()
+});
+var UpdateElementStyleSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0),
+  elementId: zod.z.string(),
+  fillColor: zod.z.string().optional(),
+  fillMode: zod.z.string().optional(),
+  fillGradientStops: zod.z.array(
+    zod.z.object({
+      color: zod.z.string(),
+      position: zod.z.number(),
+      opacity: zod.z.number().optional()
+    })
+  ).optional(),
+  fillGradientAngle: zod.z.number().optional(),
+  fillGradientType: zod.z.string().optional(),
+  fillOpacity: zod.z.number().optional(),
+  strokeColor: zod.z.string().optional(),
+  strokeWidth: zod.z.number().optional(),
+  strokeDash: zod.z.string().optional(),
+  strokeOpacity: zod.z.number().optional(),
+  shadowColor: zod.z.string().optional(),
+  shadowBlur: zod.z.number().optional(),
+  shadowOffsetX: zod.z.number().optional(),
+  shadowOffsetY: zod.z.number().optional(),
+  shadowOpacity: zod.z.number().optional(),
+  glowColor: zod.z.string().optional(),
+  glowRadius: zod.z.number().optional(),
+  glowOpacity: zod.z.number().optional(),
+  softEdgeRadius: zod.z.number().optional(),
+  cropLeft: zod.z.number().optional(),
+  cropTop: zod.z.number().optional(),
+  cropRight: zod.z.number().optional(),
+  cropBottom: zod.z.number().optional(),
+  brightness: zod.z.number().optional(),
+  contrast: zod.z.number().optional(),
+  grayscale: zod.z.boolean().optional(),
+  altText: zod.z.string().optional()
+});
+var FindTextSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  query: zod.z.string().describe("Text to search for"),
+  useRegex: zod.z.boolean().optional().describe("Treat query as regex"),
+  caseSensitive: zod.z.boolean().optional().describe("Case-sensitive search"),
+  slideIndexes: zod.z.array(zod.z.number().int().min(0)).optional().describe("Limit search to specific slides")
+});
+var ReplaceTextSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  query: zod.z.string().describe("Text to find"),
+  replacement: zod.z.string().describe("Replacement text"),
+  useRegex: zod.z.boolean().optional(),
+  caseSensitive: zod.z.boolean().optional(),
+  slideIndexes: zod.z.array(zod.z.number().int().min(0)).optional()
+});
+var ManageCommentsSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  action: zod.z.enum(["list", "add", "delete", "resolve"]),
+  slideIndex: zod.z.number().int().min(0).optional(),
+  text: zod.z.string().optional(),
+  author: zod.z.string().optional(),
+  commentId: zod.z.string().optional(),
+  resolved: zod.z.boolean().optional(),
+  includeResolved: zod.z.boolean().optional()
+});
+function generateElementId() {
+  return `el-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function generateSlideId() {
+  return `slide-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+}
+function describeElement(el) {
+  const base = {
+    id: el.id,
+    type: el.type,
+    x: Math.round(el.x),
+    y: Math.round(el.y),
+    width: Math.round(el.width),
+    height: Math.round(el.height)
+  };
+  if (el.rotation) {
+    base.rotation = el.rotation;
+  }
+  if (el.hidden) {
+    base.hidden = true;
+  }
+  if (el.opacity !== void 0 && el.opacity !== 1) {
+    base.opacity = el.opacity;
+  }
+  if (pptxViewerCore.hasTextProperties(el)) {
+    base.text = el.text ?? "";
+    if (el.textStyle) {
+      const ts = {};
+      if (el.textStyle.fontSize) {
+        ts.fontSize = el.textStyle.fontSize;
+      }
+      if (el.textStyle.fontFamily) {
+        ts.fontFamily = el.textStyle.fontFamily;
+      }
+      if (el.textStyle.bold) {
+        ts.bold = true;
+      }
+      if (el.textStyle.italic) {
+        ts.italic = true;
+      }
+      if (el.textStyle.underline) {
+        ts.underline = el.textStyle.underline;
+      }
+      if (el.textStyle.align) {
+        ts.align = el.textStyle.align;
+      }
+      if (el.textStyle.color) {
+        ts.color = el.textStyle.color;
+      }
+      if (Object.keys(ts).length > 0) {
+        base.textStyle = ts;
+      }
+    }
+  }
+  if ("shapeType" in el && el.shapeType) {
+    base.shapeType = el.shapeType;
+  }
+  if ("shapeStyle" in el && el.shapeStyle) {
+    const ss = {};
+    const style = el.shapeStyle;
+    if (style.fillColor) {
+      ss.fillColor = style.fillColor;
+    }
+    if (style.strokeColor) {
+      ss.strokeColor = style.strokeColor;
+    }
+    if (style.strokeWidth) {
+      ss.strokeWidth = style.strokeWidth;
+    }
+    if (Object.keys(ss).length > 0) {
+      base.shapeStyle = ss;
+    }
+  }
+  if (el.type === "image" || el.type === "picture") {
+    const img = el;
+    if (img.altText) {
+      base.altText = img.altText;
+    }
+    if (img.imagePath) {
+      base.imagePath = img.imagePath;
+    }
+    base.hasImageData = Boolean(img.imageData);
+  }
+  if (el.type === "table") {
+    const tbl = el;
+    if (tbl.tableData) {
+      base.rowCount = tbl.tableData.rows.length;
+      base.columnCount = tbl.tableData.columnWidths.length;
+      base.cells = tbl.tableData.rows.map((row) => row.cells.map((cell) => cell.text ?? ""));
+    }
+  }
+  if (el.type === "chart") {
+    base.chartType = el.chartData?.type;
+  }
+  if (el.type === "group") {
+    const grp = el;
+    base.childCount = grp.children?.length ?? 0;
+  }
+  return base;
+}
+function validateSlideIndex(slideIndex, slideCount) {
+  if (slideIndex < 0 || slideIndex >= slideCount) {
+    return `Slide index ${slideIndex} out of range (0\u2013${slideCount - 1}).`;
+  }
+  return null;
+}
+
+// src/tools/content-tools.ts
+function buildSearchRegex(query, useRegex, caseSensitive) {
+  const pattern = useRegex ? query : query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const flags = caseSensitive ? "g" : "gi";
+  return new RegExp(pattern, flags);
+}
+function findText(ctx, params) {
+  const regex = buildSearchRegex(
+    params.query,
+    params.useRegex === true,
+    params.caseSensitive === true
+  );
+  const targetIndexes = params.slideIndexes ? params.slideIndexes : ctx.pptxData.slides.map((_, i) => i);
+  const matches = [];
+  for (const si of targetIndexes) {
+    const err = validateSlideIndex(si, ctx.pptxData.slides.length);
+    if (err) {
+      throw new Error(err);
+    }
+    const slide = ctx.pptxData.slides[si];
+    for (const el of slide.elements) {
+      if (pptxViewerCore.hasTextProperties(el)) {
+        const textEl = el;
+        if (textEl.text) {
+          const localMatches = Array.from(textEl.text.matchAll(regex));
+          for (const m of localMatches) {
+            matches.push({
+              slideIndex: si,
+              elementId: el.id,
+              elementType: el.type,
+              matchedText: m[0],
+              context: textEl.text.slice(
+                Math.max(0, (m.index ?? 0) - 20),
+                (m.index ?? 0) + m[0].length + 20
+              )
+            });
+          }
+        }
+      }
+      if (el.type === "table") {
+        const tbl = el;
+        if (tbl.tableData) {
+          for (const row of tbl.tableData.rows) {
+            for (const cell of row.cells) {
+              if (cell.text) {
+                const localMatches = Array.from(cell.text.matchAll(regex));
+                for (const m of localMatches) {
+                  matches.push({
+                    slideIndex: si,
+                    elementId: el.id,
+                    elementType: "table-cell",
+                    matchedText: m[0],
+                    context: cell.text.slice(
+                      Math.max(0, (m.index ?? 0) - 20),
+                      (m.index ?? 0) + m[0].length + 20
+                    )
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (slide.notes) {
+      const noteMatches = Array.from(slide.notes.matchAll(regex));
+      for (const m of noteMatches) {
+        matches.push({
+          slideIndex: si,
+          elementId: "notes",
+          elementType: "notes",
+          matchedText: m[0],
+          context: slide.notes.slice(
+            Math.max(0, (m.index ?? 0) - 20),
+            (m.index ?? 0) + m[0].length + 20
+          )
+        });
+      }
+    }
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: {
+      query: params.query,
+      matchCount: matches.length,
+      matches
+    }
+  };
+}
+function replaceText(ctx, params) {
+  const regex = buildSearchRegex(
+    params.query,
+    params.useRegex === true,
+    params.caseSensitive === true
+  );
+  const targetIndexes = params.slideIndexes ? params.slideIndexes : ctx.pptxData.slides.map((_, i) => i);
+  let count = 0;
+  for (const si of targetIndexes) {
+    const err = validateSlideIndex(si, ctx.pptxData.slides.length);
+    if (err) {
+      throw new Error(err);
+    }
+    const slide = ctx.pptxData.slides[si];
+    for (const el of slide.elements) {
+      if (pptxViewerCore.hasTextProperties(el)) {
+        const textEl = el;
+        if (textEl.text) {
+          const before = textEl.text;
+          const after = before.replace(regex, params.replacement);
+          if (after !== before) {
+            const matchCount = Array.from(before.matchAll(regex)).length;
+            count += matchCount;
+            textEl.text = after;
+            if (textEl.textSegments && textEl.textSegments.length > 0) {
+              const firstSeg = textEl.textSegments[0];
+              const updatedFirst = firstSeg.text.replace(regex, params.replacement);
+              if (updatedFirst !== firstSeg.text) {
+                firstSeg.text = updatedFirst;
+              } else {
+                textEl.textSegments = [{ text: after, style: firstSeg.style }];
+              }
+            }
+          }
+        }
+      }
+      if (el.type === "table") {
+        const tbl = el;
+        if (tbl.tableData) {
+          for (const row of tbl.tableData.rows) {
+            for (const cell of row.cells) {
+              if (cell.text) {
+                const before = cell.text;
+                const after = before.replace(regex, params.replacement);
+                if (after !== before) {
+                  count += Array.from(before.matchAll(regex)).length;
+                  cell.text = after;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (slide.notes) {
+      const before = slide.notes;
+      const after = before.replace(regex, params.replacement);
+      if (after !== before) {
+        count += Array.from(before.matchAll(regex)).length;
+        slide.notes = after;
+      }
+    }
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: count > 0,
+    result: {
+      query: params.query,
+      replacement: params.replacement,
+      replacementCount: count
+    }
+  };
+}
+function manageComments(ctx, params) {
+  switch (params.action) {
+    case "list": {
+      const all = [];
+      for (let si = 0; si < ctx.pptxData.slides.length; si++) {
+        if (params.slideIndex !== void 0 && si !== params.slideIndex) {
+          continue;
+        }
+        const slide = ctx.pptxData.slides[si];
+        for (const c of slide.comments ?? []) {
+          if (!params.includeResolved && c.resolved) {
+            continue;
+          }
+          all.push({
+            id: c.id,
+            slideIndex: si,
+            text: c.text,
+            author: c.author,
+            createdAt: c.createdAt,
+            resolved: c.resolved
+          });
+        }
+      }
+      return {
+        pptxData: ctx.pptxData,
+        dirty: false,
+        result: { action: "list", comments: all, count: all.length }
+      };
+    }
+    case "add": {
+      if (params.slideIndex === void 0) {
+        throw new Error("slideIndex is required for add action.");
+      }
+      const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+      if (err) {
+        throw new Error(err);
+      }
+      if (!params.text) {
+        throw new Error("text is required for add action.");
+      }
+      const slide = ctx.pptxData.slides[params.slideIndex];
+      if (!slide.comments) {
+        slide.comments = [];
+      }
+      const newId = `comment-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      slide.comments.push({
+        id: newId,
+        text: params.text,
+        author: params.author,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        resolved: false
+      });
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: { action: "add", commentId: newId }
+      };
+    }
+    case "delete": {
+      if (!params.commentId) {
+        throw new Error("commentId is required for delete action.");
+      }
+      let deleted = false;
+      for (const slide of ctx.pptxData.slides) {
+        if (!slide.comments) {
+          continue;
+        }
+        const before = slide.comments.length;
+        slide.comments = slide.comments.filter((c) => c.id !== params.commentId);
+        if (slide.comments.length < before) {
+          deleted = true;
+          break;
+        }
+      }
+      if (!deleted) {
+        throw new Error(`Comment '${params.commentId}' not found.`);
+      }
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: { action: "delete", commentId: params.commentId }
+      };
+    }
+    case "resolve": {
+      if (!params.commentId) {
+        throw new Error("commentId is required for resolve action.");
+      }
+      let found = false;
+      for (const slide of ctx.pptxData.slides) {
+        const comment = slide.comments?.find((c) => c.id === params.commentId);
+        if (comment) {
+          comment.resolved = params.resolved !== false;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        throw new Error(`Comment '${params.commentId}' not found.`);
+      }
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: { action: "resolve", commentId: params.commentId }
+      };
+    }
+    default: {
+      throw new Error(`Unknown action: ${String(params.action)}`);
+    }
+  }
+}
+async function convertToMarkdown(ctx, params) {
+  const options = {
+    mediaFolderName: params.mediaFolderName ?? "media",
+    includeMetadata: params.includeMetadata !== false,
+    slideRange: params.slideRange,
+    includeSpeakerNotes: params.includeSpeakerNotes !== false,
+    semanticMode: params.semanticMode === true,
+    sourceName: params.sourceName ?? "unknown"
+  };
+  const converter = new pptxViewerCore.PptxMarkdownConverter(params.outputDir ?? ".", options);
+  const markdown = await converter.convert(ctx.pptxData);
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: {
+      markdown,
+      slidesConverted: converter.slidesConverted,
+      totalSlides: converter.presentationSlides,
+      imagesExtracted: converter.imagesExtracted
+    }
+  };
+}
+function addElement(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  const id = generateElementId();
+  const x = params.x ?? 100;
+  const y = params.y ?? 100;
+  const width = params.width ?? 300;
+  const height = params.height ?? 60;
+  switch (params.type) {
+    case "text": {
+      const el = {
+        id,
+        type: "text",
+        x,
+        y,
+        width,
+        height,
+        text: params.text ?? "",
+        textStyle: {
+          fontSize: params.fontSize,
+          fontFamily: params.fontFamily,
+          color: params.fontColor,
+          bold: params.bold,
+          italic: params.italic,
+          underline: params.underline,
+          align: params.alignment
+        },
+        textSegments: [
+          {
+            text: params.text ?? "",
+            style: {
+              fontSize: params.fontSize,
+              fontFamily: params.fontFamily,
+              color: params.fontColor,
+              bold: params.bold,
+              italic: params.italic,
+              underline: params.underline
+            }
+          }
+        ]
+      };
+      slide.elements.push(el);
+      break;
+    }
+    case "shape": {
+      const el = {
+        id,
+        type: "shape",
+        x,
+        y,
+        width,
+        height,
+        shapeType: params.shapeType ?? "rect",
+        text: params.text,
+        textStyle: params.text ? {
+          fontSize: params.fontSize,
+          fontFamily: params.fontFamily,
+          color: params.fontColor,
+          bold: params.bold,
+          italic: params.italic,
+          align: params.alignment
+        } : void 0,
+        shapeStyle: {
+          fillColor: params.fillColor,
+          strokeColor: params.strokeColor,
+          strokeWidth: params.strokeWidth
+        }
+      };
+      slide.elements.push(el);
+      break;
+    }
+    case "image": {
+      const el = {
+        id,
+        type: "image",
+        x,
+        y,
+        width,
+        height,
+        imageData: params.imageData,
+        altText: params.altText
+      };
+      slide.elements.push(el);
+      break;
+    }
+    case "table": {
+      const rowCount = params.rows ?? 2;
+      const colCount = params.columns ?? 2;
+      const colWidth = 1 / colCount;
+      const tableRows = Array.from({ length: rowCount }, (_, r) => ({
+        height: 40,
+        cells: Array.from({ length: colCount }, (__, c) => ({
+          text: params.cellData?.[r]?.[c] ?? ""
+        }))
+      }));
+      const tableEl = {
+        id,
+        type: "table",
+        x,
+        y,
+        width,
+        height: params.height ?? rowCount * 40,
+        tableData: {
+          rows: tableRows,
+          columnWidths: Array.from({ length: colCount }, () => colWidth),
+          firstRowHeader: params.headerRow ?? false
+        }
+      };
+      slide.elements.push(tableEl);
+      break;
+    }
+    case "connector": {
+      const el = {
+        id,
+        type: "connector",
+        x,
+        y,
+        width,
+        height,
+        shapeStyle: {
+          strokeColor: params.strokeColor ?? "#000000",
+          strokeWidth: params.strokeWidth ?? 1,
+          connectorStartArrow: params.startArrow,
+          connectorEndArrow: params.endArrow
+        }
+      };
+      slide.elements.push(el);
+      break;
+    }
+    default: {
+      throw new Error(`Unknown element type: ${String(params.type)}`);
+    }
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { elementId: id, slideIndex: params.slideIndex }
+  };
+}
+function updateElement(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  const el = slide.elements.find((e) => e.id === params.elementId);
+  if (!el) {
+    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
+  }
+  if (params.x !== void 0) {
+    el.x = params.x;
+  }
+  if (params.y !== void 0) {
+    el.y = params.y;
+  }
+  if (params.width !== void 0) {
+    el.width = params.width;
+  }
+  if (params.height !== void 0) {
+    el.height = params.height;
+  }
+  if (params.rotation !== void 0) {
+    el.rotation = params.rotation;
+  }
+  if (params.opacity !== void 0) {
+    el.opacity = params.opacity;
+  }
+  if (params.hidden !== void 0) {
+    el.hidden = params.hidden;
+  }
+  if (params.flipH !== void 0) {
+    el.flipHorizontal = params.flipH;
+  }
+  if (params.flipV !== void 0) {
+    el.flipVertical = params.flipV;
+  }
+  if (pptxViewerCore.hasTextProperties(el)) {
+    const textEl = el;
+    if (params.text !== void 0) {
+      textEl.text = params.text;
+      if (textEl.textSegments && textEl.textSegments.length > 0) {
+        textEl.textSegments[0].text = params.text;
+      } else {
+        textEl.textSegments = [{ text: params.text, style: {} }];
+      }
+    }
+    if (!textEl.textStyle) {
+      textEl.textStyle = {};
+    }
+    if (params.fontSize !== void 0) {
+      textEl.textStyle.fontSize = params.fontSize;
+    }
+    if (params.fontFamily !== void 0) {
+      textEl.textStyle.fontFamily = params.fontFamily;
+    }
+    if (params.fontColor !== void 0) {
+      textEl.textStyle.color = params.fontColor;
+    }
+    if (params.bold !== void 0) {
+      textEl.textStyle.bold = params.bold;
+    }
+    if (params.italic !== void 0) {
+      textEl.textStyle.italic = params.italic;
+    }
+    if (params.underline !== void 0) {
+      textEl.textStyle.underline = params.underline;
+    }
+    if (params.alignment !== void 0) {
+      textEl.textStyle.align = params.alignment;
+    }
+  }
+  if ("shapeStyle" in el && el.shapeStyle) {
+    const ss = el.shapeStyle;
+    if (params.fillColor !== void 0) {
+      ss.fillColor = params.fillColor;
+    }
+    if (params.strokeColor !== void 0) {
+      ss.strokeColor = params.strokeColor;
+    }
+    if (params.strokeWidth !== void 0) {
+      ss.strokeWidth = params.strokeWidth;
+    }
+  } else if (params.fillColor !== void 0 || params.strokeColor !== void 0 || params.strokeWidth !== void 0) {
+    if ("shapeStyle" in el) {
+      el.shapeStyle = {
+        fillColor: params.fillColor,
+        strokeColor: params.strokeColor,
+        strokeWidth: params.strokeWidth
+      };
+    }
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { elementId: params.elementId }
+  };
+}
+function deleteElements(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  const idSet = new Set(params.elementIds);
+  const notFound = params.elementIds.filter((id) => !slide.elements.some((e) => e.id === id));
+  if (notFound.length > 0) {
+    throw new Error(`Elements not found: ${notFound.join(", ")}`);
+  }
+  const before = slide.elements.length;
+  slide.elements = slide.elements.filter((e) => !idSet.has(e.id));
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { deletedCount: before - slide.elements.length }
+  };
+}
+function arrangeElements(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  if (params.action === "align") {
+    if (!params.elementIds || params.elementIds.length === 0) {
+      throw new Error("elementIds is required for align action.");
+    }
+    const targets = slide.elements.filter((e) => params.elementIds.includes(e.id));
+    if (targets.length === 0) {
+      throw new Error("No matching elements found for align.");
+    }
+    switch (params.alignment) {
+      case "left": {
+        const minX = Math.min(...targets.map((e) => e.x));
+        for (const t of targets) {
+          t.x = minX;
+        }
+        break;
+      }
+      case "right": {
+        const maxRight = Math.max(...targets.map((e) => e.x + e.width));
+        for (const t of targets) {
+          t.x = maxRight - t.width;
+        }
+        break;
+      }
+      case "top": {
+        const minY = Math.min(...targets.map((e) => e.y));
+        for (const t of targets) {
+          t.y = minY;
+        }
+        break;
+      }
+      case "bottom": {
+        const maxBottom = Math.max(...targets.map((e) => e.y + e.height));
+        for (const t of targets) {
+          t.y = maxBottom - t.height;
+        }
+        break;
+      }
+      case "centerH": {
+        const avgCX = targets.reduce((s, e) => s + e.x + e.width / 2, 0) / targets.length;
+        for (const t of targets) {
+          t.x = avgCX - t.width / 2;
+        }
+        break;
+      }
+      case "centerV": {
+        const avgCY = targets.reduce((s, e) => s + e.y + e.height / 2, 0) / targets.length;
+        for (const t of targets) {
+          t.y = avgCY - t.height / 2;
+        }
+        break;
+      }
+      default: {
+        throw new Error(`Unknown alignment: ${String(params.alignment)}`);
+      }
+    }
+  } else if (params.action === "reorderLayer") {
+    if (!params.elementId) {
+      throw new Error("elementId is required for reorderLayer action.");
+    }
+    const idx = slide.elements.findIndex((e) => e.id === params.elementId);
+    if (idx < 0) {
+      throw new Error(`Element '${params.elementId}' not found.`);
+    }
+    const [el] = slide.elements.splice(idx, 1);
+    switch (params.layerAction) {
+      case "bringToFront":
+        slide.elements.push(el);
+        break;
+      case "sendToBack":
+        slide.elements.unshift(el);
+        break;
+      case "bringForward": {
+        const newIdx = Math.min(idx + 1, slide.elements.length);
+        slide.elements.splice(newIdx, 0, el);
+        break;
+      }
+      case "sendBackward": {
+        const newIdx = Math.max(idx - 1, 0);
+        slide.elements.splice(newIdx, 0, el);
+        break;
+      }
+      default: {
+        slide.elements.splice(idx, 0, el);
+        throw new Error(`Unknown layerAction: ${String(params.layerAction)}`);
+      }
+    }
+  } else {
+    throw new Error(`Unknown action: ${String(params.action)}`);
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { slideIndex: params.slideIndex }
+  };
+}
+function cloneElement(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const srcSlide = ctx.pptxData.slides[params.slideIndex];
+  const original = srcSlide.elements.find((e) => e.id === params.elementId);
+  if (!original) {
+    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
+  }
+  const targets = params.targetSlideIndexes ?? [params.slideIndex];
+  const clonedIds = [];
+  const offsetX = params.offsetX ?? 20;
+  const offsetY = params.offsetY ?? 20;
+  for (const targetIdx of targets) {
+    const terr = validateSlideIndex(targetIdx, ctx.pptxData.slides.length);
+    if (terr) {
+      throw new Error(terr);
+    }
+    const clone = structuredClone(original);
+    clone.id = generateElementId();
+    clone.x += offsetX;
+    clone.y += offsetY;
+    ctx.pptxData.slides[targetIdx].elements.push(clone);
+    clonedIds.push(clone.id);
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { clonedIds }
+  };
+}
+function setElementAnimation(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  const elExists = slide.elements.some((e) => e.id === params.elementId);
+  if (!elExists) {
+    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
+  }
+  if (!slide.animations) {
+    slide.animations = [];
+  }
+  const existing = slide.animations.find((a) => a.elementId === params.elementId);
+  if (existing) {
+    if (params.entrance !== void 0) {
+      existing.entrance = params.entrance;
+    }
+    if (params.exit !== void 0) {
+      existing.exit = params.exit;
+    }
+    if (params.durationMs !== void 0) {
+      existing.durationMs = params.durationMs;
+    }
+    if (params.delayMs !== void 0) {
+      existing.delayMs = params.delayMs;
+    }
+    if (params.order !== void 0) {
+      existing.order = params.order;
+    }
+  } else {
+    const anim = {
+      elementId: params.elementId,
+      entrance: params.entrance,
+      exit: params.exit,
+      durationMs: params.durationMs,
+      delayMs: params.delayMs,
+      order: params.order
+    };
+    slide.animations.push(anim);
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { elementId: params.elementId }
+  };
+}
+function groupElements(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  if (params.elementIds.length < 2) {
+    throw new Error("At least 2 elements are required to form a group.");
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  const idSet = new Set(params.elementIds);
+  const children = slide.elements.filter((e) => idSet.has(e.id));
+  if (children.length !== params.elementIds.length) {
+    const missing = params.elementIds.filter((id) => !slide.elements.some((e) => e.id === id));
+    throw new Error(`Elements not found: ${missing.join(", ")}`);
+  }
+  const minX = Math.min(...children.map((e) => e.x));
+  const minY = Math.min(...children.map((e) => e.y));
+  const maxX = Math.max(...children.map((e) => e.x + e.width));
+  const maxY = Math.max(...children.map((e) => e.y + e.height));
+  const localChildren = children.map((e) => {
+    const c = structuredClone(e);
+    c.x -= minX;
+    c.y -= minY;
+    return c;
+  });
+  slide.elements = slide.elements.filter((e) => !idSet.has(e.id));
+  const groupId = generateElementId();
+  const group = {
+    id: groupId,
+    type: "group",
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY,
+    children: localChildren
+  };
+  slide.elements.push(group);
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { groupId }
+  };
+}
+function ungroupElements(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  const groupIdx = slide.elements.findIndex((e) => e.id === params.groupElementId);
+  if (groupIdx < 0) {
+    throw new Error(`Group element '${params.groupElementId}' not found.`);
+  }
+  const group = slide.elements[groupIdx];
+  if (group.type !== "group") {
+    throw new Error(`Element '${params.groupElementId}' is not a group.`);
+  }
+  const grp = group;
+  const restored = grp.children.map((child) => {
+    const c = structuredClone(child);
+    c.x += grp.x;
+    c.y += grp.y;
+    return c;
+  });
+  slide.elements.splice(groupIdx, 1, ...restored);
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { restoredIds: restored.map((c) => c.id) }
+  };
+}
+function batchUpdateElements(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  const idSet = new Set(params.elementIds);
+  let count = 0;
+  for (const el of slide.elements) {
+    if (!idSet.has(el.id)) {
+      continue;
+    }
+    if (params.x !== void 0) {
+      el.x = params.x;
+    }
+    if (params.y !== void 0) {
+      el.y = params.y;
+    }
+    if (params.width !== void 0) {
+      el.width = params.width;
+    }
+    if (params.height !== void 0) {
+      el.height = params.height;
+    }
+    if (params.rotation !== void 0) {
+      el.rotation = params.rotation;
+    }
+    if (params.opacity !== void 0) {
+      el.opacity = params.opacity;
+    }
+    if (params.hidden !== void 0) {
+      el.hidden = params.hidden;
+    }
+    count++;
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { updatedCount: count }
+  };
+}
+
+// src/tools/slide-tools.ts
+function getSlide(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: {
+      slideIndex: params.slideIndex,
+      slideNumber: slide.slideNumber,
+      hidden: slide.hidden ?? false,
+      layoutName: slide.layoutName,
+      backgroundColor: slide.backgroundColor,
+      notes: slide.notes ?? "",
+      commentCount: slide.comments?.length ?? 0,
+      elements: slide.elements.map(describeElement)
+    }
+  };
+}
+function addSlide(ctx, params) {
+  const { slides } = ctx.pptxData;
+  const insertAt = params.insertAfterIndex !== void 0 && params.insertAfterIndex >= 0 ? Math.min(params.insertAfterIndex + 1, slides.length) : slides.length;
+  const newSlide = {
+    id: generateSlideId(),
+    rId: "",
+    slideNumber: insertAt + 1,
+    elements: [],
+    backgroundColor: params.backgroundColor
+  };
+  slides.splice(insertAt, 0, newSlide);
+  slides.forEach((s, i) => {
+    s.slideNumber = i + 1;
+  });
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { newSlideIndex: insertAt, slideCount: slides.length }
+  };
+}
+function deleteSlides(ctx, params) {
+  const { slides } = ctx.pptxData;
+  if (!params.slideIndexes || params.slideIndexes.length === 0) {
+    throw new Error("slideIndexes is required for the delete action.");
+  }
+  const indexSet = new Set(params.slideIndexes);
+  const invalid = params.slideIndexes.filter((i) => i < 0 || i >= slides.length);
+  if (invalid.length > 0) {
+    throw new Error(
+      `Invalid slide indexes: ${invalid.join(", ")}. Valid range: 0\u2013${slides.length - 1}.`
+    );
+  }
+  if (indexSet.size >= slides.length) {
+    throw new Error("Cannot delete all slides. At least one slide must remain.");
+  }
+  ctx.pptxData.slides = slides.filter((_, i) => !indexSet.has(i));
+  ctx.pptxData.slides.forEach((s, i) => {
+    s.slideNumber = i + 1;
+  });
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { deletedCount: indexSet.size, slideCount: ctx.pptxData.slides.length }
+  };
+}
+function reorderSlides(ctx, params) {
+  const { slides } = ctx.pptxData;
+  if (!params.newOrder || params.newOrder.length !== slides.length) {
+    throw new Error(
+      `newOrder must have exactly ${slides.length} indexes. Got ${params.newOrder?.length ?? 0}.`
+    );
+  }
+  const sorted = [...params.newOrder].sort((a, b) => a - b);
+  const expected = slides.map((_, i) => i);
+  if (JSON.stringify(sorted) !== JSON.stringify(expected)) {
+    throw new Error(
+      `newOrder must contain each index from 0 to ${slides.length - 1} exactly once.`
+    );
+  }
+  ctx.pptxData.slides = params.newOrder.map((idx) => slides[idx]);
+  ctx.pptxData.slides.forEach((s, i) => {
+    s.slideNumber = i + 1;
+  });
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { slideCount: ctx.pptxData.slides.length }
+  };
+}
+function duplicateSlide(ctx, params) {
+  const { slides } = ctx.pptxData;
+  const err = validateSlideIndex(params.slideIndex, slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const original = slides[params.slideIndex];
+  const clone = structuredClone(original);
+  clone.id = generateSlideId();
+  clone.rId = "";
+  for (const el of clone.elements) {
+    el.id = generateElementId();
+  }
+  const insertIndex = params.targetIndex ?? params.slideIndex + 1;
+  slides.splice(insertIndex, 0, clone);
+  slides.forEach((s, i) => {
+    s.slideNumber = i + 1;
+  });
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { newSlideIndex: insertIndex, slideCount: slides.length }
+  };
+}
+function updateSlideProperties(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  if (params.backgroundColor !== void 0) {
+    slide.backgroundColor = params.backgroundColor;
+  }
+  if (params.backgroundGradient !== void 0) {
+    slide.backgroundGradient = params.backgroundGradient;
+  }
+  if (params.backgroundImage !== void 0) {
+    slide.backgroundImage = params.backgroundImage;
+  }
+  if (params.notes !== void 0) {
+    slide.notes = params.notes;
+  }
+  if (params.hidden !== void 0) {
+    slide.hidden = params.hidden;
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { slideIndex: params.slideIndex }
+  };
+}
+function setSlideTransition(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  if (params.type === "none") {
+    slide.transition = void 0;
+  } else {
+    const transition = {
+      type: params.type
+    };
+    if (params.durationMs !== void 0) {
+      transition.durationMs = params.durationMs;
+    }
+    if (params.direction !== void 0) {
+      transition.direction = params.direction;
+    }
+    if (params.advanceOnClick !== void 0) {
+      transition.advanceOnClick = params.advanceOnClick;
+    }
+    if (params.advanceAfterMs !== void 0) {
+      transition.advanceAfterMs = params.advanceAfterMs;
+    }
+    slide.transition = transition;
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { slideIndex: params.slideIndex, transitionType: params.type }
+  };
+}
+function setCanvasSize(ctx, params) {
+  ctx.pptxData.width = params.width;
+  ctx.pptxData.height = params.height;
+  if (ctx.pptxData.widthEmu !== void 0) {
+    ctx.pptxData.widthEmu = Math.round(params.width * 12700);
+  }
+  if (ctx.pptxData.heightEmu !== void 0) {
+    ctx.pptxData.heightEmu = Math.round(params.height * 12700);
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { canvasWidth: params.width, canvasHeight: params.height }
+  };
+}
+function updateElementStyle(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  const el = slide.elements.find((e) => e.id === params.elementId);
+  if (!el) {
+    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
+  }
+  if ("shapeStyle" in el) {
+    if (!el.shapeStyle) {
+      el.shapeStyle = {};
+    }
+    const ss = el.shapeStyle;
+    if (params.fillColor !== void 0) {
+      ss.fillColor = params.fillColor;
+    }
+    if (params.fillMode !== void 0) {
+      ss.fillMode = params.fillMode;
+    }
+    if (params.fillGradientStops !== void 0) {
+      ss.fillGradientStops = params.fillGradientStops;
+    }
+    if (params.fillGradientAngle !== void 0) {
+      ss.fillGradientAngle = params.fillGradientAngle;
+    }
+    if (params.fillGradientType !== void 0) {
+      ss.fillGradientType = params.fillGradientType;
+    }
+    if (params.fillOpacity !== void 0) {
+      ss.fillOpacity = params.fillOpacity;
+    }
+    if (params.strokeColor !== void 0) {
+      ss.strokeColor = params.strokeColor;
+    }
+    if (params.strokeWidth !== void 0) {
+      ss.strokeWidth = params.strokeWidth;
+    }
+    if (params.strokeDash !== void 0) {
+      ss.strokeDash = params.strokeDash;
+    }
+    if (params.strokeOpacity !== void 0) {
+      ss.strokeOpacity = params.strokeOpacity;
+    }
+    if (params.shadowColor !== void 0) {
+      ss.shadowColor = params.shadowColor;
+    }
+    if (params.shadowBlur !== void 0) {
+      ss.shadowBlur = params.shadowBlur;
+    }
+    if (params.shadowOffsetX !== void 0) {
+      ss.shadowOffsetX = params.shadowOffsetX;
+    }
+    if (params.shadowOffsetY !== void 0) {
+      ss.shadowOffsetY = params.shadowOffsetY;
+    }
+    if (params.shadowOpacity !== void 0) {
+      ss.shadowOpacity = params.shadowOpacity;
+    }
+    if (params.glowColor !== void 0) {
+      ss.glowColor = params.glowColor;
+    }
+    if (params.glowRadius !== void 0) {
+      ss.glowRadius = params.glowRadius;
+    }
+    if (params.glowOpacity !== void 0) {
+      ss.glowOpacity = params.glowOpacity;
+    }
+    if (params.softEdgeRadius !== void 0) {
+      ss.softEdgeRadius = params.softEdgeRadius;
+    }
+  }
+  if (el.type === "image" || el.type === "picture") {
+    const img = el;
+    if (params.altText !== void 0) {
+      img.altText = params.altText;
+    }
+    if (params.cropLeft !== void 0) {
+      img.cropLeft = params.cropLeft;
+    }
+    if (params.cropTop !== void 0) {
+      img.cropTop = params.cropTop;
+    }
+    if (params.cropRight !== void 0) {
+      img.cropRight = params.cropRight;
+    }
+    if (params.cropBottom !== void 0) {
+      img.cropBottom = params.cropBottom;
+    }
+    if (params.brightness !== void 0 || params.contrast !== void 0 || params.grayscale !== void 0) {
+      if (!img.imageEffects) {
+        img.imageEffects = {};
+      }
+      if (params.brightness !== void 0) {
+        img.imageEffects.brightness = params.brightness;
+      }
+      if (params.contrast !== void 0) {
+        img.imageEffects.contrast = params.contrast;
+      }
+      if (params.grayscale !== void 0) {
+        img.imageEffects.grayscale = params.grayscale;
+      }
+    }
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { elementId: params.elementId }
+  };
+}
+function runAccessibilityCheck(ctx) {
+  const issues = [];
+  for (let si = 0; si < ctx.pptxData.slides.length; si++) {
+    const slide = ctx.pptxData.slides[si];
+    let slideHasText = false;
+    for (const el of slide.elements) {
+      if (el.type === "image" || el.type === "picture") {
+        const img = el;
+        if (!img.altText) {
+          issues.push({
+            slideIndex: si,
+            elementId: el.id,
+            severity: "error",
+            message: `Image element '${el.id}' has no alt text.`
+          });
+        }
+      }
+      if (pptxViewerCore.hasTextProperties(el)) {
+        const textEl = el;
+        slideHasText = true;
+        if (!textEl.text || textEl.text.trim() === "") {
+          issues.push({
+            slideIndex: si,
+            elementId: el.id,
+            severity: "info",
+            message: `Text element '${el.id}' is empty.`
+          });
+        }
+        const fs = textEl.textStyle?.fontSize;
+        if (fs !== void 0 && fs < 10) {
+          issues.push({
+            slideIndex: si,
+            elementId: el.id,
+            severity: "warning",
+            message: `Text element '${el.id}' has very small font size (${fs}pt < 10pt).`
+          });
+        }
+        const textColor = textEl.textStyle?.color?.toLowerCase();
+        const bgColor = slide.backgroundColor?.toLowerCase();
+        if (textColor && bgColor && textColor === bgColor) {
+          issues.push({
+            slideIndex: si,
+            elementId: el.id,
+            severity: "error",
+            message: `Text element '${el.id}' has same color as slide background (${textColor}).`
+          });
+        }
+      }
+    }
+    if (!slideHasText) {
+      issues.push({
+        slideIndex: si,
+        severity: "warning",
+        message: `Slide ${si + 1} contains no text elements.`
+      });
+    }
+  }
+  const errorCount = issues.filter((i) => i.severity === "error").length;
+  const warningCount = issues.filter((i) => i.severity === "warning").length;
+  const infoCount = issues.filter((i) => i.severity === "info").length;
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: {
+      slideCount: ctx.pptxData.slides.length,
+      totalIssues: issues.length,
+      errorCount,
+      warningCount,
+      infoCount,
+      issues
+    }
+  };
+}
+
+// src/tools/table-tools.ts
+function updateTableCells(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  const el = slide.elements.find((e) => e.id === params.elementId);
+  if (!el) {
+    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
+  }
+  if (el.type !== "table") {
+    throw new Error(`Element '${params.elementId}' is not a table.`);
+  }
+  const tbl = el;
+  if (!tbl.tableData) {
+    throw new Error(`Table '${params.elementId}' has no tableData.`);
+  }
+  let count = 0;
+  for (const cellUpdate of params.cells) {
+    const row = tbl.tableData.rows[cellUpdate.row];
+    if (!row) {
+      throw new Error(
+        `Row ${cellUpdate.row} out of range (table has ${tbl.tableData.rows.length} rows).`
+      );
+    }
+    const cell = row.cells[cellUpdate.col];
+    if (!cell) {
+      throw new Error(`Column ${cellUpdate.col} out of range (row has ${row.cells.length} cells).`);
+    }
+    cell.text = cellUpdate.text;
+    count++;
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { updatedCount: count }
+  };
+}
+function manageTableStructure(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  const el = slide.elements.find((e) => e.id === params.elementId);
+  if (!el) {
+    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
+  }
+  if (el.type !== "table") {
+    throw new Error(`Element '${params.elementId}' is not a table.`);
+  }
+  const tbl = el;
+  if (!tbl.tableData) {
+    throw new Error(`Table '${params.elementId}' has no tableData.`);
+  }
+  const { rows, columnWidths } = tbl.tableData;
+  const colCount = columnWidths.length;
+  const rowCount = rows.length;
+  switch (params.action) {
+    case "insertRow": {
+      const pos = params.position !== void 0 ? Math.min(Math.max(params.position, 0), rowCount) : rowCount;
+      const newRow = {
+        height: 40,
+        cells: Array.from({ length: colCount }, (_, c) => ({
+          text: params.cellTexts?.[c] ?? ""
+        }))
+      };
+      rows.splice(pos, 0, newRow);
+      break;
+    }
+    case "deleteRow": {
+      if (rowCount <= 1) {
+        throw new Error("Cannot delete the last row of a table.");
+      }
+      const ref = params.referenceIndex ?? rowCount - 1;
+      if (ref < 0 || ref >= rowCount) {
+        throw new Error(`Row index ${ref} out of range (0\u2013${rowCount - 1}).`);
+      }
+      rows.splice(ref, 1);
+      break;
+    }
+    case "insertColumn": {
+      const pos = params.position !== void 0 ? Math.min(Math.max(params.position, 0), colCount) : colCount;
+      const newWidth = 1 / (colCount + 1);
+      const scaleFactor = colCount / (colCount + 1);
+      for (let i = 0; i < columnWidths.length; i++) {
+        columnWidths[i] *= scaleFactor;
+      }
+      columnWidths.splice(pos, 0, newWidth);
+      for (let r = 0; r < rows.length; r++) {
+        rows[r].cells.splice(pos, 0, {
+          text: params.cellTexts?.[r] ?? ""
+        });
+      }
+      break;
+    }
+    case "deleteColumn": {
+      if (colCount <= 1) {
+        throw new Error("Cannot delete the last column of a table.");
+      }
+      const ref = params.referenceIndex ?? colCount - 1;
+      if (ref < 0 || ref >= colCount) {
+        throw new Error(`Column index ${ref} out of range (0\u2013${colCount - 1}).`);
+      }
+      const removedWidth = columnWidths[ref];
+      columnWidths.splice(ref, 1);
+      const remaining = columnWidths.length;
+      if (remaining > 0) {
+        const extra = removedWidth / remaining;
+        for (let i = 0; i < columnWidths.length; i++) {
+          columnWidths[i] += extra;
+        }
+      }
+      for (const row of rows) {
+        row.cells.splice(ref, 1);
+      }
+      break;
+    }
+    default: {
+      throw new Error(`Unknown action: ${String(params.action)}`);
+    }
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: {
+      rowCount: tbl.tableData.rows.length,
+      columnCount: tbl.tableData.columnWidths.length
+    }
+  };
+}
+var PPTX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+async function loadPresentation(filePath, execCtx) {
+  const rawBytes = await execCtx.filesystem.readFile(filePath);
+  if (execCtx.collaboration) {
+    const room = execCtx.collaboration.getRoom(filePath);
+    if (room) {
+      const codec = execCtx.collaboration.getCodec(filePath);
+      if (codec) {
+        const currentBytes = await codec.dehydrate(room.ydoc);
+        const handler2 = new pptxViewerCore.PptxHandler();
+        const pptxData2 = await handler2.load(currentBytes.buffer);
+        return { pptxData: pptxData2, rawBytes };
+      }
+    }
+  }
+  const handler = new pptxViewerCore.PptxHandler();
+  const pptxData = await handler.load(rawBytes.buffer);
+  return { pptxData, rawBytes };
+}
+async function savePresentation(filePath, pptxData, rawBytes, execCtx) {
+  const handler = new pptxViewerCore.PptxHandler();
+  await handler.load(rawBytes.buffer);
+  const outputBytes = await handler.save(pptxData.slides, {
+    headerFooter: pptxData.headerFooter
+  });
+  if (execCtx.collaboration) {
+    const room = execCtx.collaboration.getRoom(filePath);
+    if (room) {
+      const codec = execCtx.collaboration.getCodec(filePath);
+      if (codec) {
+        const origin = execCtx.collaboration.agentOrigin(execCtx.agentName ?? "pptx-tool");
+        await codec.hydrate(room.ydoc, outputBytes, origin);
+        if (execCtx.viewer) {
+          execCtx.viewer.replaceContent(filePath, outputBytes, {
+            markDirty: false,
+            mimeType: PPTX_MIME_TYPE
+          });
+        }
+        return { savedToDisk: false, routedThroughCollaboration: true };
+      }
+    }
+  }
+  await execCtx.filesystem.writeFile(filePath, outputBytes);
+  if (execCtx.viewer) {
+    execCtx.viewer.replaceContent(filePath, outputBytes, {
+      markDirty: false,
+      mimeType: PPTX_MIME_TYPE
+    });
+  }
+  return { savedToDisk: true, routedThroughCollaboration: false };
+}
+async function executeToolWithContext(filePath, execCtx, toolFn) {
+  const { pptxData, rawBytes } = await loadPresentation(filePath, execCtx);
+  const toolResult = await toolFn({ pptxData });
+  if (toolResult.dirty) {
+    const saveResult = await savePresentation(filePath, toolResult.pptxData, rawBytes, execCtx);
+    return { ...toolResult.result, ...saveResult };
+  }
+  return toolResult.result;
+}
+
+// src/mcp/handlers.ts
+var nodeFs = {
+  readFile: async (path) => new Uint8Array(await promises.readFile(path)),
+  writeFile: async (path, data) => {
+    await promises.writeFile(path, data);
+  }
+};
+function createMcpContext() {
+  return { filesystem: nodeFs };
+}
+async function runMcpTool(filePath, fn) {
+  const ctx = createMcpContext();
+  return executeToolWithContext(filePath, ctx, fn);
+}
+
+// src/mcp/server.ts
+function createServer() {
+  const server2 = new mcp_js.McpServer({
+    name: "pptx-viewer-tools",
+    version: "1.0.0"
+  });
+  server2.registerTool(
+    "get_slide",
+    {
+      description: "Inspect a single slide \u2014 returns layout, notes, elements",
+      inputSchema: GetSlideSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => getSlide(ctx, { slideIndex: params.slideIndex })
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "add_slide",
+    {
+      description: "Add a new blank slide to the presentation",
+      inputSchema: AddSlideSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => addSlide(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "delete_slides",
+    {
+      description: "Delete one or more slides by index",
+      inputSchema: DeleteSlidesSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => deleteSlides(ctx, {
+          slideIndexes: params.slideIndexes
+        })
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "reorder_slides",
+    {
+      description: "Reorder slides by providing a new index array",
+      inputSchema: ReorderSlidesSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => reorderSlides(ctx, { newOrder: params.newOrder })
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "duplicate_slide",
+    {
+      description: "Duplicate a slide with new element IDs",
+      inputSchema: DuplicateSlideSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => duplicateSlide(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "update_slide_properties",
+    {
+      description: "Update slide background, notes, or visibility",
+      inputSchema: UpdateSlidePropertiesSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => updateSlideProperties(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "set_slide_transition",
+    {
+      description: "Set or remove a slide transition effect",
+      inputSchema: SetSlideTransitionSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => setSlideTransition(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "set_canvas_size",
+    {
+      description: "Change the presentation canvas dimensions",
+      inputSchema: SetCanvasSizeSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => setCanvasSize(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "add_element",
+    {
+      description: "Add a text, shape, image, table, or connector element",
+      inputSchema: AddElementSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => addElement(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "update_element",
+    {
+      description: "Update element position, size, text, or style",
+      inputSchema: UpdateElementSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => updateElement(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "delete_elements",
+    {
+      description: "Delete one or more elements by ID",
+      inputSchema: DeleteElementsSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => deleteElements(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "arrange_elements",
+    {
+      description: "Align elements or change z-order (layer)",
+      inputSchema: ArrangeElementsSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => arrangeElements(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "clone_element",
+    {
+      description: "Clone an element within or across slides",
+      inputSchema: CloneElementSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => cloneElement(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "set_element_animation",
+    {
+      description: "Set entrance/exit animation on an element",
+      inputSchema: SetElementAnimationSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => setElementAnimation(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "group_elements",
+    {
+      description: "Group multiple elements into a group",
+      inputSchema: GroupElementsSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => groupElements(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "ungroup_elements",
+    {
+      description: "Ungroup a group element back to individual elements",
+      inputSchema: UngroupElementsSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => ungroupElements(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "batch_update_elements",
+    {
+      description: "Apply the same properties to multiple elements",
+      inputSchema: BatchUpdateElementsSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => batchUpdateElements(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "update_table_cells",
+    {
+      description: "Update text content of table cells",
+      inputSchema: UpdateTableCellsSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => updateTableCells(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "manage_table_structure",
+    {
+      description: "Insert or delete table rows and columns",
+      inputSchema: ManageTableStructureSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => manageTableStructure(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "update_element_style",
+    {
+      description: "Update fill, stroke, shadow, glow, or image effects",
+      inputSchema: UpdateElementStyleSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => updateElementStyle(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "run_accessibility_check",
+    {
+      description: "Audit the presentation for accessibility issues",
+      inputSchema: AccessibilityCheckSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => runAccessibilityCheck(ctx)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "find_text",
+    {
+      description: "Search for text across all slides",
+      inputSchema: FindTextSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => findText(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "replace_text",
+    {
+      description: "Find and replace text across slides",
+      inputSchema: ReplaceTextSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => replaceText(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "manage_comments",
+    {
+      description: "List, add, delete, or resolve slide comments",
+      inputSchema: ManageCommentsSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => manageComments(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "convert_to_markdown",
+    {
+      description: "Convert the presentation to Markdown format",
+      inputSchema: ConvertToMarkdownSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => convertToMarkdown(ctx, params)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  return server2;
+}
+
+// src/mcp/index.ts
+var server = createServer();
+var transport = new stdio_js.StdioServerTransport();
+void server.connect(transport);