pptx-viewer-mcp 1.1.26 → 1.2.0

package/dist/mcp/index.js

@@ -262,6 +262,241 @@ var ManageCommentsSchema = zod.z.object({
   resolved: zod.z.boolean().optional(),
   includeResolved: zod.z.boolean().optional()
 });
+var GetThemeInfoSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file")
+});
+var ApplyThemePresetSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  presetName: zod.z.string().describe(
+    'Theme preset name (e.g. "OFFICE", "MODERN_BLUE", "EARTH", "MONOCHROME", "VIBRANT", "CORPORATE", "MINIMAL", "DARK")'
+  )
+});
+var UpdateThemeColorsSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  dk1: zod.z.string().optional().describe("Dark 1 color (hex)"),
+  lt1: zod.z.string().optional().describe("Light 1 color (hex)"),
+  dk2: zod.z.string().optional().describe("Dark 2 color (hex)"),
+  lt2: zod.z.string().optional().describe("Light 2 color (hex)"),
+  accent1: zod.z.string().optional().describe("Accent 1 color (hex)"),
+  accent2: zod.z.string().optional().describe("Accent 2 color (hex)"),
+  accent3: zod.z.string().optional().describe("Accent 3 color (hex)"),
+  accent4: zod.z.string().optional().describe("Accent 4 color (hex)"),
+  accent5: zod.z.string().optional().describe("Accent 5 color (hex)"),
+  accent6: zod.z.string().optional().describe("Accent 6 color (hex)"),
+  hlink: zod.z.string().optional().describe("Hyperlink color (hex)"),
+  folHlink: zod.z.string().optional().describe("Followed hyperlink color (hex)")
+});
+var UpdateThemeFontsSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  majorFont: zod.z.string().optional().describe("Heading (major) font family"),
+  minorFont: zod.z.string().optional().describe("Body (minor) font family")
+});
+var UpdateChartSchema = 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("Chart element ID"),
+  chartType: zod.z.string().optional().describe("New chart type (bar, line, pie, scatter, area, doughnut, radar)"),
+  title: zod.z.string().optional().describe("Chart title"),
+  grouping: zod.z.enum(["clustered", "stacked", "percentStacked"]).optional().describe("Bar/column grouping"),
+  legend: zod.z.object({
+    show: zod.z.boolean().optional(),
+    position: zod.z.string().optional().describe("Legend position: b, t, l, r, tr")
+  }).optional().describe("Legend configuration"),
+  dataLabels: zod.z.object({
+    show: zod.z.boolean().optional(),
+    showValue: zod.z.boolean().optional(),
+    showCategory: zod.z.boolean().optional(),
+    showSeriesName: zod.z.boolean().optional(),
+    showPercent: zod.z.boolean().optional()
+  }).optional().describe("Data label configuration"),
+  axis: zod.z.object({
+    type: zod.z.string().describe("Axis type: valAx, catAx, dateAx, serAx"),
+    edit: zod.z.object({
+      min: zod.z.number().nullable().optional(),
+      max: zod.z.number().nullable().optional(),
+      majorUnit: zod.z.number().nullable().optional(),
+      title: zod.z.string().nullable().optional(),
+      numberFormat: zod.z.string().optional(),
+      majorGridlines: zod.z.boolean().optional(),
+      minorGridlines: zod.z.boolean().optional()
+    })
+  }).optional().describe("Axis configuration"),
+  categories: zod.z.array(zod.z.string()).optional().describe("Category axis labels")
+});
+var AddChartSeriesSchema = 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("Chart element ID"),
+  name: zod.z.string().describe("Series name"),
+  values: zod.z.array(zod.z.number()).describe("Data values"),
+  color: zod.z.string().optional().describe("Series color (hex)")
+});
+var RemoveChartSeriesSchema = 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("Chart element ID"),
+  seriesIndex: zod.z.number().int().min(0).describe("Zero-based series index to remove")
+});
+var UpdateChartSeriesDataSchema = 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("Chart element ID"),
+  seriesIndex: zod.z.number().int().min(0).describe("Zero-based series index"),
+  values: zod.z.array(zod.z.number()).describe("New data values")
+});
+var CreateChartSchema = 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"),
+  chartType: zod.z.string().describe("Chart type (bar, line, pie, scatter, area, doughnut, radar)"),
+  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"),
+  title: zod.z.string().optional().describe("Chart title"),
+  categories: zod.z.array(zod.z.string()).optional().describe("Category labels"),
+  series: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      values: zod.z.array(zod.z.number()),
+      color: zod.z.string().optional()
+    })
+  ).optional().describe("Data series"),
+  legend: zod.z.object({
+    show: zod.z.boolean(),
+    position: zod.z.string().optional()
+  }).optional().describe("Legend configuration")
+});
+var ManageSmartArtSchema = 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("SmartArt element ID"),
+  action: zod.z.enum([
+    "getNodes",
+    "addNode",
+    "removeNode",
+    "updateNodeText",
+    "reorderNode",
+    "promoteNode",
+    "demoteNode",
+    "decompose"
+  ]).describe("SmartArt action"),
+  nodeId: zod.z.string().optional().describe("Node ID (required for most actions)"),
+  text: zod.z.string().optional().describe("Text for addNode or updateNodeText"),
+  afterNodeId: zod.z.string().optional().describe("Insert after this node ID"),
+  direction: zod.z.number().optional().describe("Reorder direction: 1 (forward) or -1 (backward)")
+});
+var FindPlaceholdersSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file")
+});
+var ApplyTemplateSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()).describe("Template data: keys are placeholder names, values are replacement values")
+});
+var GetMetadataSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file")
+});
+var UpdateMetadataSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  title: zod.z.string().optional().describe("Presentation title"),
+  subject: zod.z.string().optional().describe("Subject"),
+  creator: zod.z.string().optional().describe("Creator/author name"),
+  keywords: zod.z.string().optional().describe("Keywords (comma-separated)"),
+  description: zod.z.string().optional().describe("Description/comments"),
+  lastModifiedBy: zod.z.string().optional().describe("Last modified by"),
+  category: zod.z.string().optional().describe("Category"),
+  company: zod.z.string().optional().describe("Company name"),
+  manager: zod.z.string().optional().describe("Manager name"),
+  customProperties: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      value: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean()])
+    })
+  ).optional().describe("Custom properties to set")
+});
+var ManageSectionsSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  action: zod.z.enum(["list", "add", "remove", "reorder", "moveSlides", "getForSlide"]).describe("Section action"),
+  name: zod.z.string().optional().describe("Section name (for add)"),
+  slideIndices: zod.z.array(zod.z.number().int().min(0)).optional().describe("Slide indices (for add, moveSlides)"),
+  sectionId: zod.z.string().optional().describe("Section ID (for remove, moveSlides)"),
+  sectionIds: zod.z.array(zod.z.string()).optional().describe("Ordered section IDs (for reorder)"),
+  slideIndex: zod.z.number().int().min(0).optional().describe("Slide index (for getForSlide)")
+});
+var ExportToSvgSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndices: zod.z.array(zod.z.number().int().min(0)).optional().describe("Specific slides to export (all if omitted)"),
+  includeHidden: zod.z.boolean().optional().describe("Include hidden slides"),
+  defaultFontFamily: zod.z.string().optional().describe("Default font family for SVG"),
+  defaultFontSize: zod.z.number().optional().describe("Default font size")
+});
+var ExportSlideSvgSchema = 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 to export"),
+  defaultFontFamily: zod.z.string().optional().describe("Default font family for SVG"),
+  defaultFontSize: zod.z.number().optional().describe("Default font size")
+});
+var ManageHyperlinksSchema = 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"),
+  action: zod.z.enum(["list", "set", "remove"]).describe("Hyperlink action"),
+  elementId: zod.z.string().optional().describe("Element ID (for set/remove)"),
+  trigger: zod.z.enum(["click", "hover"]).optional().describe("Action trigger (default: click)"),
+  url: zod.z.string().optional().describe("URL for the hyperlink"),
+  tooltip: zod.z.string().optional().describe("Tooltip text"),
+  targetSlideIndex: zod.z.number().int().min(0).optional().describe("Target slide index for internal links"),
+  actionType: zod.z.enum(["url", "slide", "nextSlide", "prevSlide", "firstSlide", "lastSlide", "endShow"]).optional().describe("Link action type")
+});
+var ReplaceGeometrySchema = 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("Shape element ID"),
+  shapeType: zod.z.string().optional().describe('Preset shape type (e.g. "roundRect", "star5", "ellipse", "diamond")'),
+  svgPath: zod.z.string().optional().describe("Custom SVG path data (mutually exclusive with shapeType)"),
+  pathWidth: zod.z.number().optional().describe("Width of SVG path coordinate space"),
+  pathHeight: zod.z.number().optional().describe("Height of SVG path coordinate space"),
+  adjustments: zod.z.record(zod.z.string(), zod.z.number()).optional().describe("Shape adjustment values")
+});
+var SetElementLockSchema = 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 lock/unlock"),
+  locked: zod.z.boolean().describe("Whether the element should be locked"),
+  noMove: zod.z.boolean().optional().describe("Prevent moving"),
+  noResize: zod.z.boolean().optional().describe("Prevent resizing"),
+  noRotation: zod.z.boolean().optional().describe("Prevent rotation"),
+  noSelect: zod.z.boolean().optional().describe("Prevent selection"),
+  noTextEdit: zod.z.boolean().optional().describe("Prevent text editing")
+});
+var ValidatePresentationSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file")
+});
+var RepairPresentationSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file")
+});
+var GetPresentationPropertiesSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file")
+});
+var UpdatePresentationPropertiesSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  showType: zod.z.enum(["presented", "browsed", "kiosk"]).optional().describe("Slideshow mode"),
+  loopContinuously: zod.z.boolean().optional().describe("Loop the slideshow"),
+  showWithNarration: zod.z.boolean().optional().describe("Play narration"),
+  showWithAnimation: zod.z.boolean().optional().describe("Play animations"),
+  advanceMode: zod.z.enum(["manual", "useTimings"]).optional().describe("Slide advance mode"),
+  showSlidesMode: zod.z.enum(["all", "customShow", "range"]).optional().describe("Which slides to show"),
+  showSlidesFrom: zod.z.number().int().min(1).optional().describe("Range start (1-based)"),
+  showSlidesTo: zod.z.number().int().min(1).optional().describe("Range end (1-based)"),
+  penColor: zod.z.string().optional().describe("Annotation pen color (hex)")
+});
+var GetLayoutsSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file")
+});
+var ApplyLayoutSchema = 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"),
+  layoutName: zod.z.string().optional().describe("Layout name to apply"),
+  layoutType: zod.z.string().optional().describe("Layout type to apply (alternative to name)")
+});
 function generateElementId() {
   return `el-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -369,7 +604,144 @@ function validateSlideIndex(slideIndex, slideCount) {
   return null;
 }
 
-// src/tools/content-tools.ts
+// src/tools/chart-tools.ts
+function updateChart(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 !== "chart") {
+    throw new Error(`Element '${params.elementId}' is not a chart.`);
+  }
+  const chart = el;
+  if (params.chartType) {
+    pptxViewerCore.setChartType(chart, params.chartType);
+  }
+  if (params.title !== void 0) {
+    pptxViewerCore.setChartTitle(chart, params.title);
+  }
+  if (params.grouping) {
+    pptxViewerCore.setChartGrouping(chart, params.grouping);
+  }
+  if (params.legend) {
+    pptxViewerCore.setChartLegend(chart, {
+      show: params.legend.show,
+      position: params.legend.position
+    });
+  }
+  if (params.dataLabels) {
+    pptxViewerCore.setChartDataLabels(chart, params.dataLabels);
+  }
+  if (params.axis) {
+    pptxViewerCore.setChartAxis(chart, params.axis.type, params.axis.edit);
+  }
+  if (params.categories) {
+    pptxViewerCore.setChartCategories(chart, params.categories);
+  }
+  return { pptxData: ctx.pptxData, dirty: true, result: { elementId: params.elementId } };
+}
+function addChartSeriesT(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 !== "chart") {
+    throw new Error(`Element '${params.elementId}' is not a chart.`);
+  }
+  const chart = el;
+  pptxViewerCore.addChartSeries(chart, { name: params.name, values: params.values, color: params.color });
+  const seriesCount = chart.chartData?.series?.length ?? 0;
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { elementId: params.elementId, seriesCount }
+  };
+}
+function removeChartSeriesT(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 !== "chart") {
+    throw new Error(`Element '${params.elementId}' is not a chart.`);
+  }
+  const chart = el;
+  pptxViewerCore.removeChartSeries(chart, params.seriesIndex);
+  const seriesCount = chart.chartData?.series?.length ?? 0;
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { elementId: params.elementId, seriesCount }
+  };
+}
+function updateChartSeriesData(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 !== "chart") {
+    throw new Error(`Element '${params.elementId}' is not a chart.`);
+  }
+  const chart = el;
+  pptxViewerCore.updateChartSeriesValues(chart, params.seriesIndex, params.values);
+  return { pptxData: ctx.pptxData, dirty: true, result: { elementId: params.elementId } };
+}
+function createChart(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const builder = pptxViewerCore.ChartBuilder.create(
+    params.chartType
+  );
+  builder.position(params.x ?? 100, params.y ?? 100);
+  builder.size(params.width ?? 500, params.height ?? 350);
+  if (params.title) {
+    builder.title(params.title);
+  }
+  if (params.categories) {
+    builder.categories(params.categories);
+  }
+  if (params.series) {
+    for (const s of params.series) {
+      builder.addSeries(s.name, s.values, s.color);
+    }
+  }
+  if (params.legend) {
+    builder.legend(
+      params.legend.show,
+      params.legend.position
+    );
+  }
+  const chart = builder.build();
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  slide.elements.push(chart);
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { elementId: chart.id, slideIndex: params.slideIndex }
+  };
+}
 var MAX_REGEX_LEN = 200;
 function hasNestedUnboundedQuantifier(pattern) {
   return /\([^)]*[+*]\)[+*]/u.test(pattern);
@@ -1257,129 +1629,621 @@ function batchUpdateElements(ctx, params) {
     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 exportToSvg(ctx, params) {
+  if (params.slideIndices) {
+    for (const si of params.slideIndices) {
+      const err = validateSlideIndex(si, ctx.pptxData.slides.length);
+      if (err) {
+        throw new Error(err);
+      }
     }
-  };
-}
-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}.`
-    );
+  const options = {};
+  if (params.slideIndices) {
+    options.slideIndices = params.slideIndices;
   }
-  if (indexSet.size >= slides.length) {
-    throw new Error("Cannot delete all slides. At least one slide must remain.");
+  if (params.includeHidden !== void 0) {
+    options.includeHidden = params.includeHidden;
   }
-  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}.`
-    );
+  if (params.defaultFontFamily) {
+    options.defaultFontFamily = params.defaultFontFamily;
   }
-  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.`
-    );
+  if (params.defaultFontSize) {
+    options.defaultFontSize = params.defaultFontSize;
   }
-  ctx.pptxData.slides = params.newOrder.map((idx) => slides[idx]);
-  ctx.pptxData.slides.forEach((s, i) => {
-    s.slideNumber = i + 1;
-  });
+  const svgStrings = pptxViewerCore.SvgExporter.exportAll(ctx.pptxData, options);
   return {
     pptxData: ctx.pptxData,
-    dirty: true,
-    result: { slideCount: ctx.pptxData.slides.length }
+    dirty: false,
+    result: { svgStrings, slideCount: svgStrings.length }
   };
 }
-function duplicateSlide(ctx, params) {
-  const { slides } = ctx.pptxData;
-  const err = validateSlideIndex(params.slideIndex, slides.length);
+function exportSlideSvg(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.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 slide = ctx.pptxData.slides[params.slideIndex];
+  const width = ctx.pptxData.width ?? 960;
+  const height = ctx.pptxData.height ?? 540;
+  const options = {};
+  if (params.defaultFontFamily) {
+    options.defaultFontFamily = params.defaultFontFamily;
   }
-  const insertIndex = params.targetIndex ?? params.slideIndex + 1;
-  slides.splice(insertIndex, 0, clone);
-  slides.forEach((s, i) => {
-    s.slideNumber = i + 1;
-  });
+  if (params.defaultFontSize) {
+    options.defaultFontSize = params.defaultFontSize;
+  }
+  const svg = pptxViewerCore.SvgExporter.exportSlide(slide, width, height, options);
   return {
     pptxData: ctx.pptxData,
-    dirty: true,
-    result: { newSlideIndex: insertIndex, slideCount: slides.length }
+    dirty: false,
+    result: { svg, slideIndex: params.slideIndex }
   };
 }
-function updateSlideProperties(ctx, params) {
+function replaceGeometry(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) {
+  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 !== "shape") {
+    throw new Error(`Element '${params.elementId}' is not a shape.`);
+  }
+  const shape = el;
+  if (params.svgPath) {
+    pptxViewerCore.replaceWithCustomGeometry(shape, params.svgPath, params.pathWidth, params.pathHeight);
+    return {
+      pptxData: ctx.pptxData,
+      dirty: true,
+      result: { elementId: params.elementId, geometryType: "custom" }
+    };
+  }
+  if (params.shapeType) {
+    pptxViewerCore.replaceShapeGeometry(shape, params.shapeType, params.adjustments);
+    return {
+      pptxData: ctx.pptxData,
+      dirty: true,
+      result: { elementId: params.elementId, geometryType: params.shapeType }
+    };
+  }
+  throw new Error("Either shapeType or svgPath must be provided.");
+}
+
+// src/tools/hyperlink-tools.ts
+function manageHyperlinks(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  switch (params.action) {
+    case "list": {
+      const hyperlinks = [];
+      for (const el of slide.elements) {
+        if (el.actionClick) {
+          hyperlinks.push({
+            elementId: el.id,
+            trigger: "click",
+            url: el.actionClick.url,
+            tooltip: el.actionClick.tooltip,
+            targetSlideIndex: el.actionClick.targetSlideIndex,
+            actionType: el.actionClick.action
+          });
+        }
+        if (el.actionHover) {
+          hyperlinks.push({
+            elementId: el.id,
+            trigger: "hover",
+            url: el.actionHover.url,
+            tooltip: el.actionHover.tooltip,
+            targetSlideIndex: el.actionHover.targetSlideIndex,
+            actionType: el.actionHover.action
+          });
+        }
+      }
+      return { pptxData: ctx.pptxData, dirty: false, result: { action: "list", hyperlinks } };
+    }
+    case "set": {
+      if (!params.elementId) {
+        throw new Error("elementId is required for set action.");
+      }
+      const el = slide.elements.find((e) => e.id === params.elementId);
+      if (!el) {
+        throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
+      }
+      const trigger = params.trigger ?? "click";
+      const action = {};
+      if (params.url) {
+        action.url = params.url;
+      }
+      if (params.tooltip) {
+        action.tooltip = params.tooltip;
+      }
+      if (params.targetSlideIndex !== void 0) {
+        action.targetSlideIndex = params.targetSlideIndex;
+      }
+      if (params.actionType) {
+        switch (params.actionType) {
+          case "url":
+            action.action = "ppaction://hlinkpres";
+            break;
+          case "slide":
+            action.action = "ppaction://hlinksldjump";
+            break;
+          case "nextSlide":
+            action.action = "ppaction://hlinkshowjump?jump=nextslide";
+            break;
+          case "prevSlide":
+            action.action = "ppaction://hlinkshowjump?jump=previousslide";
+            break;
+          case "firstSlide":
+            action.action = "ppaction://hlinkshowjump?jump=firstslide";
+            break;
+          case "lastSlide":
+            action.action = "ppaction://hlinkshowjump?jump=lastslide";
+            break;
+          case "endShow":
+            action.action = "ppaction://hlinkshowjump?jump=endshow";
+            break;
+        }
+      }
+      if (trigger === "click") {
+        el.actionClick = action;
+      } else {
+        el.actionHover = action;
+      }
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: { action: "set", elementId: params.elementId }
+      };
+    }
+    case "remove": {
+      if (!params.elementId) {
+        throw new Error("elementId is required for remove action.");
+      }
+      const el = slide.elements.find((e) => e.id === params.elementId);
+      if (!el) {
+        throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
+      }
+      const trigger = params.trigger ?? "click";
+      if (trigger === "click") {
+        el.actionClick = void 0;
+      } else {
+        el.actionHover = void 0;
+      }
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: { action: "remove", elementId: params.elementId }
+      };
+    }
+    default:
+      throw new Error(`Unknown hyperlink action: ${String(params.action)}`);
+  }
+}
+function getLayouts(ctx) {
+  const layouts = [];
+  if (ctx.pptxData.slideMasters) {
+    for (const master of ctx.pptxData.slideMasters) {
+      if (master.layouts) {
+        for (const layout of master.layouts) {
+          layouts.push({
+            name: layout.name ?? "Unknown",
+            path: layout.path
+          });
+        }
+      }
+    }
+  }
+  if (ctx.pptxData.layoutOptions) {
+    for (const opt of ctx.pptxData.layoutOptions) {
+      if (!layouts.some((l) => l.path === opt.path)) {
+        layouts.push({ name: opt.name, path: opt.path, type: opt.type });
+      }
+    }
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: { layouts, count: layouts.length }
+  };
+}
+function applyLayout(ctx, params) {
+  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
+  if (err) {
+    throw new Error(err);
+  }
+  let layout;
+  if (params.layoutName) {
+    layout = pptxViewerCore.findLayoutByName(ctx.pptxData, params.layoutName);
+  } else if (params.layoutType) {
+    layout = pptxViewerCore.findLayoutByType(ctx.pptxData, params.layoutType);
+  } else {
+    throw new Error("Either layoutName or layoutType must be provided.");
+  }
+  if (!layout) {
+    throw new Error(
+      `Layout not found: ${params.layoutName ?? params.layoutType}. Use get_layouts to see available layouts.`
+    );
+  }
+  const slide = ctx.pptxData.slides[params.slideIndex];
+  slide.layoutName = layout.name;
+  if (layout.path) {
+    slide.layoutPath = layout.path;
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { slideIndex: params.slideIndex, layoutName: layout.name ?? "Unknown" }
+  };
+}
+function setElementLockT(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 idx = slide.elements.findIndex((e) => e.id === params.elementId);
+  if (idx < 0) {
+    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
+  }
+  const extraLocks = {};
+  if (params.noMove !== void 0) {
+    extraLocks["noMove"] = params.noMove;
+  }
+  if (params.noResize !== void 0) {
+    extraLocks["noResize"] = params.noResize;
+  }
+  if (params.noRotation !== void 0) {
+    extraLocks["noRotation"] = params.noRotation;
+  }
+  if (params.noSelect !== void 0) {
+    extraLocks["noSelect"] = params.noSelect;
+  }
+  if (params.noTextEdit !== void 0) {
+    extraLocks["noTextEdit"] = params.noTextEdit;
+  }
+  const updated = pptxViewerCore.setElementLocked(slide.elements[idx], params.locked, extraLocks);
+  slide.elements[idx] = updated;
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { elementId: params.elementId, locked: params.locked }
+  };
+}
+
+// src/tools/metadata-tools.ts
+function getMetadata(ctx) {
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: {
+      coreProperties: ctx.pptxData.coreProperties,
+      appProperties: ctx.pptxData.appProperties,
+      customProperties: ctx.pptxData.customProperties,
+      slideCount: ctx.pptxData.slides.length
+    }
+  };
+}
+function updateMetadata(ctx, params) {
+  const updated = [];
+  if (params.title !== void 0 || params.subject !== void 0 || params.creator !== void 0 || params.keywords !== void 0 || params.description !== void 0 || params.lastModifiedBy !== void 0 || params.category !== void 0) {
+    if (!ctx.pptxData.coreProperties) {
+      ctx.pptxData.coreProperties = {};
+    }
+    const cp = ctx.pptxData.coreProperties;
+    if (params.title !== void 0) {
+      cp.title = params.title;
+      updated.push("title");
+    }
+    if (params.subject !== void 0) {
+      cp.subject = params.subject;
+      updated.push("subject");
+    }
+    if (params.creator !== void 0) {
+      cp.creator = params.creator;
+      updated.push("creator");
+    }
+    if (params.keywords !== void 0) {
+      cp.keywords = params.keywords;
+      updated.push("keywords");
+    }
+    if (params.description !== void 0) {
+      cp.description = params.description;
+      updated.push("description");
+    }
+    if (params.lastModifiedBy !== void 0) {
+      cp.lastModifiedBy = params.lastModifiedBy;
+      updated.push("lastModifiedBy");
+    }
+    if (params.category !== void 0) {
+      cp.category = params.category;
+      updated.push("category");
+    }
+  }
+  if (params.company !== void 0 || params.manager !== void 0) {
+    if (!ctx.pptxData.appProperties) {
+      ctx.pptxData.appProperties = {};
+    }
+    const ap = ctx.pptxData.appProperties;
+    if (params.company !== void 0) {
+      ap.company = params.company;
+      updated.push("company");
+    }
+    if (params.manager !== void 0) {
+      ap.manager = params.manager;
+      updated.push("manager");
+    }
+  }
+  if (params.customProperties) {
+    if (!ctx.pptxData.customProperties) {
+      ctx.pptxData.customProperties = [];
+    }
+    for (const cp of params.customProperties) {
+      const valueStr = String(cp.value);
+      const vtType = typeof cp.value === "number" ? "i4" : typeof cp.value === "boolean" ? "bool" : "lpwstr";
+      const existing = ctx.pptxData.customProperties.find((p) => p.name === cp.name);
+      if (existing) {
+        existing.value = valueStr;
+        existing.type = vtType;
+      } else {
+        ctx.pptxData.customProperties.push({ name: cp.name, value: valueStr, type: vtType });
+      }
+      updated.push(`custom:${cp.name}`);
+    }
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: updated.length > 0,
+    result: { updated }
+  };
+}
+
+// src/tools/presentation-tools.ts
+function getPresentationProperties(ctx) {
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: {
+      properties: ctx.pptxData.presentationProperties,
+      slideCount: ctx.pptxData.slides.length,
+      width: ctx.pptxData.width,
+      height: ctx.pptxData.height
+    }
+  };
+}
+function updatePresentationProperties(ctx, params) {
+  if (!ctx.pptxData.presentationProperties) {
+    ctx.pptxData.presentationProperties = {};
+  }
+  const pp = ctx.pptxData.presentationProperties;
+  if (params.showType !== void 0) {
+    pp.showType = params.showType;
+  }
+  if (params.loopContinuously !== void 0) {
+    pp.loopContinuously = params.loopContinuously;
+  }
+  if (params.showWithNarration !== void 0) {
+    pp.showWithNarration = params.showWithNarration;
+  }
+  if (params.showWithAnimation !== void 0) {
+    pp.showWithAnimation = params.showWithAnimation;
+  }
+  if (params.advanceMode !== void 0) {
+    pp.advanceMode = params.advanceMode;
+  }
+  if (params.showSlidesMode !== void 0) {
+    pp.showSlidesMode = params.showSlidesMode;
+  }
+  if (params.showSlidesFrom !== void 0) {
+    pp.showSlidesFrom = params.showSlidesFrom;
+  }
+  if (params.showSlidesTo !== void 0) {
+    pp.showSlidesTo = params.showSlidesTo;
+  }
+  if (params.penColor !== void 0) {
+    pp.penColor = params.penColor;
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { properties: pp }
+  };
+}
+function manageSections(ctx, params) {
+  switch (params.action) {
+    case "list": {
+      const sections = (ctx.pptxData.sections ?? []).map((s) => ({
+        id: s.id,
+        name: s.name,
+        slideIds: s.slideIds,
+        collapsed: s.collapsed,
+        color: s.color
+      }));
+      return { pptxData: ctx.pptxData, dirty: false, result: { action: "list", sections } };
+    }
+    case "add": {
+      if (!params.name) {
+        throw new Error("name is required for add action.");
+      }
+      const section = pptxViewerCore.addSection(ctx.pptxData, params.name, params.slideIndices ?? []);
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: {
+          action: "add",
+          section: { id: section.id, name: section.name, slideIds: section.slideIds }
+        }
+      };
+    }
+    case "remove": {
+      if (!params.sectionId) {
+        throw new Error("sectionId is required for remove action.");
+      }
+      const success = pptxViewerCore.removeSection(ctx.pptxData, params.sectionId);
+      return { pptxData: ctx.pptxData, dirty: success, result: { action: "remove", success } };
+    }
+    case "reorder": {
+      if (!params.sectionIds) {
+        throw new Error("sectionIds is required for reorder action.");
+      }
+      pptxViewerCore.reorderSections(ctx.pptxData, params.sectionIds);
+      return { pptxData: ctx.pptxData, dirty: true, result: { action: "reorder", success: true } };
+    }
+    case "moveSlides": {
+      if (!params.sectionId) {
+        throw new Error("sectionId is required for moveSlides action.");
+      }
+      if (!params.slideIndices) {
+        throw new Error("slideIndices is required for moveSlides action.");
+      }
+      const success = pptxViewerCore.moveSlidesToSection(ctx.pptxData, params.slideIndices, params.sectionId);
+      return { pptxData: ctx.pptxData, dirty: success, result: { action: "moveSlides", success } };
+    }
+    case "getForSlide": {
+      if (params.slideIndex === void 0) {
+        throw new Error("slideIndex is required for getForSlide action.");
+      }
+      const section = pptxViewerCore.getSectionForSlide(ctx.pptxData, params.slideIndex);
+      const info = section ? { id: section.id, name: section.name, slideIds: section.slideIds } : null;
+      return {
+        pptxData: ctx.pptxData,
+        dirty: false,
+        result: { action: "getForSlide", section: info }
+      };
+    }
+    default:
+      throw new Error(`Unknown section action: ${String(params.action)}`);
+  }
+}
+
+// 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) {
@@ -1447,6 +2311,164 @@ function setCanvasSize(ctx, params) {
     result: { canvasWidth: params.width, canvasHeight: params.height }
   };
 }
+function extractNodes(data) {
+  if (!data.nodes) {
+    return [];
+  }
+  return data.nodes.map((n) => ({
+    id: n.id,
+    text: n.text ?? "",
+    children: n.children?.map((c) => ({ id: c.id, text: c.text ?? "" }))
+  }));
+}
+function manageSmartArt(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 !== "smartArt") {
+    throw new Error(`Element '${params.elementId}' is not a SmartArt.`);
+  }
+  const smartArt = el;
+  if (!smartArt.smartArtData) {
+    throw new Error(`SmartArt '${params.elementId}' has no data.`);
+  }
+  switch (params.action) {
+    case "getNodes": {
+      return {
+        pptxData: ctx.pptxData,
+        dirty: false,
+        result: {
+          action: "getNodes",
+          elementId: params.elementId,
+          nodes: extractNodes(smartArt.smartArtData)
+        }
+      };
+    }
+    case "addNode": {
+      smartArt.smartArtData = pptxViewerCore.addSmartArtNode(
+        smartArt.smartArtData,
+        params.text ?? "",
+        params.afterNodeId
+      );
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: {
+          action: "addNode",
+          elementId: params.elementId,
+          nodes: extractNodes(smartArt.smartArtData)
+        }
+      };
+    }
+    case "removeNode": {
+      if (!params.nodeId) {
+        throw new Error("nodeId is required for removeNode.");
+      }
+      smartArt.smartArtData = pptxViewerCore.removeSmartArtNode(smartArt.smartArtData, params.nodeId);
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: {
+          action: "removeNode",
+          elementId: params.elementId,
+          nodes: extractNodes(smartArt.smartArtData)
+        }
+      };
+    }
+    case "updateNodeText": {
+      if (!params.nodeId) {
+        throw new Error("nodeId is required for updateNodeText.");
+      }
+      smartArt.smartArtData = pptxViewerCore.updateSmartArtNodeText(
+        smartArt.smartArtData,
+        params.nodeId,
+        params.text ?? ""
+      );
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: { action: "updateNodeText", elementId: params.elementId }
+      };
+    }
+    case "reorderNode": {
+      if (!params.nodeId) {
+        throw new Error("nodeId is required for reorderNode.");
+      }
+      const dir = params.direction ?? 1;
+      smartArt.smartArtData = pptxViewerCore.reorderSmartArtNode(smartArt.smartArtData, params.nodeId, dir);
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: {
+          action: "reorderNode",
+          elementId: params.elementId,
+          nodes: extractNodes(smartArt.smartArtData)
+        }
+      };
+    }
+    case "promoteNode": {
+      if (!params.nodeId) {
+        throw new Error("nodeId is required for promoteNode.");
+      }
+      smartArt.smartArtData = pptxViewerCore.promoteSmartArtNode(smartArt.smartArtData, params.nodeId);
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: {
+          action: "promoteNode",
+          elementId: params.elementId,
+          nodes: extractNodes(smartArt.smartArtData)
+        }
+      };
+    }
+    case "demoteNode": {
+      if (!params.nodeId) {
+        throw new Error("nodeId is required for demoteNode.");
+      }
+      smartArt.smartArtData = pptxViewerCore.demoteSmartArtNode(smartArt.smartArtData, params.nodeId);
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: {
+          action: "demoteNode",
+          elementId: params.elementId,
+          nodes: extractNodes(smartArt.smartArtData)
+        }
+      };
+    }
+    case "decompose": {
+      const bounds = {
+        x: smartArt.x,
+        y: smartArt.y,
+        width: smartArt.width,
+        height: smartArt.height
+      };
+      const decomposed = pptxViewerCore.decomposeSmartArt(smartArt.smartArtData, bounds);
+      if (!decomposed || decomposed.length === 0) {
+        throw new Error("Failed to decompose SmartArt into shapes.");
+      }
+      const idx = slide.elements.indexOf(el);
+      slide.elements.splice(idx, 1, ...decomposed);
+      return {
+        pptxData: ctx.pptxData,
+        dirty: true,
+        result: {
+          action: "decompose",
+          elementId: params.elementId,
+          decomposedCount: decomposed.length
+        }
+      };
+    }
+    default:
+      throw new Error(`Unknown SmartArt action: ${String(params.action)}`);
+  }
+}
 function updateElementStyle(ctx, params) {
   const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
   if (err) {
@@ -1751,17 +2773,144 @@ function manageTableStructure(ctx, params) {
       }
       break;
     }
-    default: {
-      throw new Error(`Unknown action: ${String(params.action)}`);
+    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
+    }
+  };
+}
+function findPlaceholdersT(ctx) {
+  const placeholders = pptxViewerCore.findPlaceholders(ctx.pptxData);
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: { placeholders, count: placeholders.length }
+  };
+}
+function applyTemplateT(ctx, params) {
+  pptxViewerCore.applyTemplate(ctx.pptxData, params.data);
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { applied: true, slideCount: ctx.pptxData.slides.length }
+  };
+}
+function getThemeInfo(ctx) {
+  const theme = ctx.pptxData.theme;
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: {
+      themeName: theme?.name,
+      colorScheme: theme?.colorScheme,
+      fontScheme: theme?.fontScheme,
+      availablePresets: Object.keys(pptxViewerCore.ThemePresets)
+    }
+  };
+}
+function applyThemePreset(ctx, params) {
+  const preset = pptxViewerCore.getThemePreset(params.presetName);
+  if (!preset) {
+    throw new Error(
+      `Unknown theme preset: "${params.presetName}". Available: ${Object.keys(pptxViewerCore.ThemePresets).join(", ")}`
+    );
+  }
+  if (!ctx.pptxData.theme) {
+    ctx.pptxData.theme = {};
+  }
+  const theme = ctx.pptxData.theme;
+  theme.name = preset.name;
+  theme.colorScheme = preset.colors;
+  if (preset.fonts) {
+    theme.fontScheme = preset.fonts;
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: {
+      appliedPreset: params.presetName,
+      colorScheme: theme.colorScheme
+    }
+  };
+}
+function updateThemeColors(ctx, params) {
+  if (!ctx.pptxData.theme) {
+    ctx.pptxData.theme = {};
+  }
+  const theme = ctx.pptxData.theme;
+  if (!theme.colorScheme) {
+    theme.colorScheme = {
+      dk1: "#000000",
+      lt1: "#FFFFFF",
+      dk2: "#44546A",
+      lt2: "#E7E6E6",
+      accent1: "#4472C4",
+      accent2: "#ED7D31",
+      accent3: "#A5A5A5",
+      accent4: "#FFC000",
+      accent5: "#5B9BD5",
+      accent6: "#70AD47",
+      hlink: "#0563C1",
+      folHlink: "#954F72"
+    };
+  }
+  const cs = theme.colorScheme;
+  for (const key of Object.keys(params)) {
+    if (params[key] !== void 0) {
+      cs[key] = params[key];
     }
   }
   return {
     pptxData: ctx.pptxData,
     dirty: true,
+    result: { colorScheme: cs }
+  };
+}
+function updateThemeFonts(ctx, params) {
+  if (!ctx.pptxData.theme) {
+    ctx.pptxData.theme = {};
+  }
+  const theme = ctx.pptxData.theme;
+  if (!theme.fontScheme) {
+    theme.fontScheme = {};
+  }
+  if (params.majorFont !== void 0) {
+    theme.fontScheme.majorFont = { latin: params.majorFont };
+  }
+  if (params.minorFont !== void 0) {
+    theme.fontScheme.minorFont = { latin: params.minorFont };
+  }
+  return {
+    pptxData: ctx.pptxData,
+    dirty: true,
+    result: { fontScheme: theme.fontScheme }
+  };
+}
+async function validatePresentation(rawBytes) {
+  const result = await pptxViewerCore.validatePptx(rawBytes);
+  return {
+    valid: result.valid,
+    issueCount: result.issues.length,
+    errors: result.issues.filter((i) => i.severity === "error").length,
+    warnings: result.issues.filter((i) => i.severity === "warning").length,
+    issues: result.issues
+  };
+}
+async function repairPresentation(rawBytes) {
+  const result = await pptxViewerCore.repairPptx(rawBytes);
+  return {
     result: {
-      rowCount: tbl.tableData.rows.length,
-      columnCount: tbl.tableData.columnWidths.length
-    }
+      repairCount: result.repairs.length,
+      repairs: result.repairs
+    },
+    repairedBytes: result.repaired
   };
 }
 var PPTX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
@@ -2400,6 +3549,372 @@ function createServer() {
       };
     }
   );
+  server2.registerTool(
+    "get_theme_info",
+    {
+      description: "Get current theme information (colors, fonts, available presets)",
+      inputSchema: GetThemeInfoSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(params.filePath, (ctx) => getThemeInfo(ctx));
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "apply_theme_preset",
+    {
+      description: "Apply a built-in theme preset to the presentation",
+      inputSchema: ApplyThemePresetSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => applyThemePreset(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "update_theme_colors",
+    {
+      description: "Update individual theme colors (accent1-6, dk1/2, lt1/2, hlink, folHlink)",
+      inputSchema: UpdateThemeColorsSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => updateThemeColors(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "update_theme_fonts",
+    {
+      description: "Update theme heading (major) and body (minor) fonts",
+      inputSchema: UpdateThemeFontsSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => updateThemeFonts(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "update_chart",
+    {
+      description: "Update chart type, title, legend, data labels, axis, or categories",
+      inputSchema: UpdateChartSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => updateChart(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "add_chart_series",
+    {
+      description: "Add a data series to an existing chart",
+      inputSchema: AddChartSeriesSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => addChartSeriesT(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "remove_chart_series",
+    {
+      description: "Remove a data series from a chart by index",
+      inputSchema: RemoveChartSeriesSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => removeChartSeriesT(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "update_chart_series_data",
+    {
+      description: "Update data values for a chart series",
+      inputSchema: UpdateChartSeriesDataSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => updateChartSeriesData(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "create_chart",
+    {
+      description: "Create a new chart element on a slide",
+      inputSchema: CreateChartSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => createChart(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "manage_smart_art",
+    {
+      description: "Manage SmartArt: get nodes, add/remove/reorder/promote/demote nodes, or decompose to shapes",
+      inputSchema: ManageSmartArtSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => manageSmartArt(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "find_placeholders",
+    {
+      description: "Discover all {{placeholder}} tokens in the presentation",
+      inputSchema: FindPlaceholdersSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => findPlaceholdersT(ctx)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "apply_template",
+    {
+      description: "Replace {{placeholder}} tokens with provided values (mail merge)",
+      inputSchema: ApplyTemplateSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => applyTemplateT(ctx, { data: params.data })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "get_metadata",
+    {
+      description: "Get presentation metadata (title, author, keywords, custom properties)",
+      inputSchema: GetMetadataSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => getMetadata(ctx)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "update_metadata",
+    {
+      description: "Update presentation metadata (title, author, company, custom properties)",
+      inputSchema: UpdateMetadataSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => updateMetadata(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "manage_sections",
+    {
+      description: "List, add, remove, reorder sections or move slides between sections",
+      inputSchema: ManageSectionsSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => manageSections(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "export_to_svg",
+    {
+      description: "Export all or specific slides to SVG strings",
+      inputSchema: ExportToSvgSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => exportToSvg(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "export_slide_svg",
+    {
+      description: "Export a single slide to SVG",
+      inputSchema: ExportSlideSvgSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => exportSlideSvg(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "manage_hyperlinks",
+    {
+      description: "List, set, or remove hyperlinks/actions on elements",
+      inputSchema: ManageHyperlinksSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => manageHyperlinks(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "replace_geometry",
+    {
+      description: "Replace a shape element geometry with a preset or custom SVG path",
+      inputSchema: ReplaceGeometrySchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => replaceGeometry(ctx, {
+          ...params,
+          adjustments: params.adjustments
+        })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "set_element_lock",
+    {
+      description: "Lock or unlock an element (prevent move, resize, rotation, selection, text edit)",
+      inputSchema: SetElementLockSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => setElementLockT(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "validate_presentation",
+    {
+      description: "Validate PPTX structural integrity (content types, relationships, XML)",
+      inputSchema: ValidatePresentationSchema.shape
+    },
+    async (params) => {
+      const { readFile: readFile2 } = await import('fs/promises');
+      const safePath = resolveScopedFilePath(params.filePath);
+      const bytes = await readFile2(safePath);
+      const result = await validatePresentation(bytes.buffer);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "repair_presentation",
+    {
+      description: "Auto-repair common PPTX structural issues",
+      inputSchema: RepairPresentationSchema.shape
+    },
+    async (params) => {
+      const { readFile: readFile2, writeFile: writeFile2 } = await import('fs/promises');
+      const safePath = resolveScopedFilePath(params.filePath);
+      const bytes = await readFile2(safePath);
+      const { result, repairedBytes } = await repairPresentation(
+        bytes.buffer
+      );
+      if (result.repairCount > 0) {
+        await writeFile2(safePath, new Uint8Array(repairedBytes));
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "get_presentation_properties",
+    {
+      description: "Get slideshow properties (show type, loop, advance mode, slide range)",
+      inputSchema: GetPresentationPropertiesSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => getPresentationProperties(ctx)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "update_presentation_properties",
+    {
+      description: "Update slideshow properties (show type, loop, advance mode, pen color)",
+      inputSchema: UpdatePresentationPropertiesSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => updatePresentationProperties(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "get_layouts",
+    {
+      description: "List available slide layouts from the presentation masters",
+      inputSchema: GetLayoutsSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(params.filePath, (ctx) => getLayouts(ctx));
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "apply_layout",
+    {
+      description: "Apply a slide layout to a specific slide",
+      inputSchema: ApplyLayoutSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => applyLayout(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
   return server2;
 }