pptx-viewer-mcp 1.1.26 → 1.2.0

package/dist/index.js

@@ -1588,41 +1588,1009 @@ async function convertToMarkdown(ctx, params) {
     }
   };
 }
+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 }
+  };
+}
+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 }
+  };
+}
+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 mergePresentationT(ctx, params) {
+  const options = {};
+  if (params.slideIndices) {
+    options.slideIndices = params.slideIndices;
+  }
+  if (params.insertAt !== void 0) {
+    options.insertAt = params.insertAt;
+  }
+  if (params.keepSourceTheme !== void 0) {
+    options.keepSourceTheme = params.keepSourceTheme;
+  }
+  const added = pptxViewerCore.mergePresentation(ctx.pptxData, params.sourceData, options);
+  return {
+    pptxData: ctx.pptxData,
+    dirty: added > 0,
+    result: { slidesAdded: added, totalSlides: ctx.pptxData.slides.length }
+  };
+}
+function diffPresentationsT(ctx, params) {
+  const diff = pptxViewerCore.diffPresentations(ctx.pptxData, params.otherData);
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: diff
+  };
+}
+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 }
+  };
+}
+
+// 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 }
+  };
+}
+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)}`);
+  }
+}
+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);
+      }
+    }
+  }
+  const options = {};
+  if (params.slideIndices) {
+    options.slideIndices = params.slideIndices;
+  }
+  if (params.includeHidden !== void 0) {
+    options.includeHidden = params.includeHidden;
+  }
+  if (params.defaultFontFamily) {
+    options.defaultFontFamily = params.defaultFontFamily;
+  }
+  if (params.defaultFontSize) {
+    options.defaultFontSize = params.defaultFontSize;
+  }
+  const svgStrings = pptxViewerCore.SvgExporter.exportAll(ctx.pptxData, options);
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: { svgStrings, slideCount: svgStrings.length }
+  };
+}
+function exportSlideSvg(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 width = ctx.pptxData.width ?? 960;
+  const height = ctx.pptxData.height ?? 540;
+  const options = {};
+  if (params.defaultFontFamily) {
+    options.defaultFontFamily = params.defaultFontFamily;
+  }
+  if (params.defaultFontSize) {
+    options.defaultFontSize = params.defaultFontSize;
+  }
+  const svg = pptxViewerCore.SvgExporter.exportSlide(slide, width, height, options);
+  return {
+    pptxData: ctx.pptxData,
+    dirty: false,
+    result: { svg, slideIndex: params.slideIndex }
+  };
+}
+
+// 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 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];
+  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.");
+}
+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 }
+  };
+}
+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: {
+      repairCount: result.repairs.length,
+      repairs: result.repairs
+    },
+    repairedBytes: result.repaired
+  };
+}
+
+// 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 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" }
+  };
+}
 
 Object.defineProperty(exports, "PptxHandler", {
   enumerable: true,
   get: function () { return pptxViewerCore.PptxHandler; }
 });
+exports.addChartSeriesT = addChartSeriesT;
 exports.addElement = addElement;
 exports.addSlide = addSlide;
+exports.applyLayout = applyLayout;
+exports.applyTemplateT = applyTemplateT;
+exports.applyThemePreset = applyThemePreset;
 exports.arrangeElements = arrangeElements;
 exports.batchUpdateElements = batchUpdateElements;
 exports.cloneElement = cloneElement;
 exports.convertToMarkdown = convertToMarkdown;
+exports.createChart = createChart;
 exports.deleteElements = deleteElements;
 exports.deleteSlides = deleteSlides;
 exports.describeElement = describeElement;
+exports.diffPresentationsT = diffPresentationsT;
 exports.duplicateSlide = duplicateSlide;
 exports.executeToolWithContext = executeToolWithContext;
+exports.exportSlideSvg = exportSlideSvg;
+exports.exportToSvg = exportToSvg;
 exports.extractSlideText = extractSlideText;
+exports.findPlaceholdersT = findPlaceholdersT;
 exports.findText = findText;
 exports.generateElementId = generateElementId;
 exports.generateSlideId = generateSlideId;
+exports.getLayouts = getLayouts;
+exports.getMetadata = getMetadata;
+exports.getPresentationProperties = getPresentationProperties;
 exports.getSlide = getSlide;
+exports.getThemeInfo = getThemeInfo;
 exports.groupElements = groupElements;
 exports.loadPresentation = loadPresentation;
 exports.manageComments = manageComments;
+exports.manageHyperlinks = manageHyperlinks;
+exports.manageSections = manageSections;
+exports.manageSmartArt = manageSmartArt;
 exports.manageTableStructure = manageTableStructure;
+exports.mergePresentationT = mergePresentationT;
+exports.removeChartSeriesT = removeChartSeriesT;
 exports.reorderSlides = reorderSlides;
+exports.repairPresentation = repairPresentation;
+exports.replaceGeometry = replaceGeometry;
 exports.replaceText = replaceText;
 exports.runAccessibilityCheck = runAccessibilityCheck;
 exports.savePresentation = savePresentation;
 exports.setCanvasSize = setCanvasSize;
 exports.setElementAnimation = setElementAnimation;
+exports.setElementLockT = setElementLockT;
 exports.setSlideTransition = setSlideTransition;
 exports.ungroupElements = ungroupElements;
+exports.updateChart = updateChart;
+exports.updateChartSeriesData = updateChartSeriesData;
 exports.updateElement = updateElement;
 exports.updateElementStyle = updateElementStyle;
+exports.updateMetadata = updateMetadata;
+exports.updatePresentationProperties = updatePresentationProperties;
 exports.updateSlideProperties = updateSlideProperties;
 exports.updateTableCells = updateTableCells;
+exports.updateThemeColors = updateThemeColors;
+exports.updateThemeFonts = updateThemeFonts;
+exports.validatePresentation = validatePresentation;
 exports.validateSlideIndex = validateSlideIndex;