pptx-viewer-mcp 2.5.8 → 2.6.0

package/dist/mcp/index.js

@@ -1,13 +1,12 @@
-#!/usr/bin/env node
 'use strict';
 
-var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var zod = require('zod');
-var pptxViewerCore = require('pptx-viewer-core');
+var automation = require('ooxml-core/pptx/automation');
 var promises = require('fs/promises');
 var path = require('path');
 
+// src/mcp/server.ts
 var GetSlideSchema = zod.z.object({
   filePath: zod.z.string().describe("Path to the PPTX file"),
   slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index")
@@ -932,3162 +931,86 @@ var SetOleObjectNameSchema = zod.z.object({
   elementId: zod.z.string().describe("OLE element ID"),
   name: zod.z.string().describe("New Object Name (p:oleObj/@name); blank/whitespace clears it")
 });
-function generateElementId() {
-  return `el-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function generateSlideId() {
-  return `slide-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-}
-function describeElement(el) {
-  const base = {
-    id: el.id,
-    type: el.type,
-    x: Math.round(el.x),
-    y: Math.round(el.y),
-    width: Math.round(el.width),
-    height: Math.round(el.height)
-  };
-  if (el.rotation) {
-    base.rotation = el.rotation;
-  }
-  if (el.hidden) {
-    base.hidden = true;
-  }
-  if (el.opacity !== void 0 && el.opacity !== 1) {
-    base.opacity = el.opacity;
-  }
-  if (pptxViewerCore.hasTextProperties(el)) {
-    base.text = el.text ?? "";
-    if (el.textStyle) {
-      const ts = {};
-      if (el.textStyle.fontSize) {
-        ts.fontSize = el.textStyle.fontSize;
-      }
-      if (el.textStyle.fontFamily) {
-        ts.fontFamily = el.textStyle.fontFamily;
-      }
-      if (el.textStyle.bold) {
-        ts.bold = true;
-      }
-      if (el.textStyle.italic) {
-        ts.italic = true;
-      }
-      if (el.textStyle.underline) {
-        ts.underline = el.textStyle.underline;
-      }
-      if (el.textStyle.align) {
-        ts.align = el.textStyle.align;
-      }
-      if (el.textStyle.color) {
-        ts.color = el.textStyle.color;
-      }
-      if (Object.keys(ts).length > 0) {
-        base.textStyle = ts;
-      }
-    }
-  }
-  if ("shapeType" in el && el.shapeType) {
-    base.shapeType = el.shapeType;
-  }
-  if ("shapeStyle" in el && el.shapeStyle) {
-    const ss = {};
-    const style = el.shapeStyle;
-    if (style.fillColor) {
-      ss.fillColor = style.fillColor;
-    }
-    if (style.strokeColor) {
-      ss.strokeColor = style.strokeColor;
-    }
-    if (style.strokeWidth) {
-      ss.strokeWidth = style.strokeWidth;
-    }
-    if (Object.keys(ss).length > 0) {
-      base.shapeStyle = ss;
-    }
-  }
-  if (el.type === "image" || el.type === "picture") {
-    const img = el;
-    if (img.altText) {
-      base.altText = img.altText;
-    }
-    if (img.imagePath) {
-      base.imagePath = img.imagePath;
-    }
-    base.hasImageData = Boolean(img.imageData);
-  }
-  if (el.type === "table") {
-    const tbl = el;
-    if (tbl.tableData) {
-      base.rowCount = tbl.tableData.rows.length;
-      base.columnCount = tbl.tableData.columnWidths.length;
-      base.cells = tbl.tableData.rows.map((row) => row.cells.map((cell) => cell.text ?? ""));
-    }
-  }
-  if (el.type === "chart" && el.chartData) {
-    base.chartType = pptxViewerCore.resolveDisplayedChartTypeName(el.chartData);
-  }
-  if (el.type === "group") {
-    const grp = el;
-    base.childCount = grp.children?.length ?? 0;
-  }
-  return base;
-}
-function validateSlideIndex(slideIndex, slideCount) {
-  if (slideIndex < 0 || slideIndex >= slideCount) {
-    return `Slide index ${slideIndex} out of range (0\u2013${slideCount - 1}).`;
-  }
-  return null;
-}
-
-// src/tools/chart-formatting-tools.ts
-function findChartElement(ctx, slideIndex, elementId) {
-  const err = validateSlideIndex(slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[slideIndex];
-  const el = slide.elements.find((e) => e.id === elementId);
-  if (!el) {
-    throw new Error(`Element '${elementId}' not found on slide ${slideIndex}.`);
-  }
-  if (el.type !== "chart") {
-    throw new Error(`Element '${elementId}' is not a chart.`);
-  }
-  return el;
-}
-function formatChartDataPoint(ctx, params) {
-  const chart = findChartElement(ctx, params.slideIndex, params.elementId);
-  if (params.clearStyle) {
-    pptxViewerCore.setChartDataPointStyle(chart, params.seriesIndex, params.pointIndex, null);
-  } else if (params.fillColor !== void 0 || params.strokeColor !== void 0 || params.strokeWidth !== void 0 || params.strokeDashStyle !== void 0) {
-    pptxViewerCore.setChartDataPointStyle(chart, params.seriesIndex, params.pointIndex, {
-      ...params.fillColor !== void 0 ? { fillColor: params.fillColor } : {},
-      ...params.strokeColor !== void 0 ? { strokeColor: params.strokeColor } : {},
-      ...params.strokeWidth !== void 0 ? { strokeWidth: params.strokeWidth } : {},
-      ...params.strokeDashStyle !== void 0 ? { strokeDashStyle: params.strokeDashStyle } : {}
-    });
-  }
-  if (params.explosion !== void 0) {
-    pptxViewerCore.setChartDataPointExplosion(chart, params.seriesIndex, params.pointIndex, params.explosion);
-  }
-  if (params.marker !== void 0) {
-    pptxViewerCore.setChartDataPointMarker(chart, params.seriesIndex, params.pointIndex, params.marker);
-  }
-  return { pptxData: ctx.pptxData, dirty: true, result: { elementId: params.elementId } };
-}
-function formatChartDataLabel(ctx, params) {
-  const chart = findChartElement(ctx, params.slideIndex, params.elementId);
-  if (params.remove) {
-    pptxViewerCore.setChartDataPointLabel(chart, params.seriesIndex, params.pointIndex, null);
-    return { pptxData: ctx.pptxData, dirty: true, result: { elementId: params.elementId } };
-  }
-  pptxViewerCore.setChartDataPointLabel(chart, params.seriesIndex, params.pointIndex, {
-    ...params.showValue !== void 0 ? { showValue: params.showValue } : {},
-    ...params.showCategory !== void 0 ? { showCategory: params.showCategory } : {},
-    ...params.showSeriesName !== void 0 ? { showSeriesName: params.showSeriesName } : {},
-    ...params.showPercent !== void 0 ? { showPercent: params.showPercent } : {},
-    ...params.showLegendKey !== void 0 ? { showLegendKey: params.showLegendKey } : {},
-    ...params.position !== void 0 ? { position: params.position } : {},
-    ...params.text !== void 0 ? { text: params.text } : {},
-    ...params.spPr !== void 0 ? { spPr: params.spPr } : {},
-    ...params.txPr !== void 0 ? { txPr: params.txPr } : {}
-  });
-  return { pptxData: ctx.pptxData, dirty: true, result: { elementId: params.elementId } };
-}
-function formatChartSeries(ctx, params) {
-  const chart = findChartElement(ctx, params.slideIndex, params.elementId);
-  if (params.marker !== void 0) {
-    if (params.marker === null) {
-      pptxViewerCore.setChartSeriesMarker(chart, params.seriesIndex, null);
-    } else if (params.marker.strokeColor !== void 0 || params.marker.strokeWidth !== void 0 || params.marker.strokeDashStyle !== void 0) {
-      pptxViewerCore.setChartSeriesMarker(chart, params.seriesIndex, {
-        symbol: params.marker.symbol ?? "circle",
-        ...params.marker.size !== void 0 ? { size: params.marker.size } : {},
-        spPr: {
-          ...params.marker.fillColor !== void 0 ? { fillColor: params.marker.fillColor } : {},
-          ...params.marker.strokeColor !== void 0 ? { strokeColor: params.marker.strokeColor } : {},
-          ...params.marker.strokeWidth !== void 0 ? { strokeWidth: params.marker.strokeWidth } : {},
-          ...params.marker.strokeDashStyle !== void 0 ? { strokeDashStyle: params.marker.strokeDashStyle } : {}
-        }
-      });
-    } else {
-      pptxViewerCore.setChartSeriesMarker(chart, params.seriesIndex, params.marker);
-    }
-  }
-  if (params.trendline !== void 0) {
-    pptxViewerCore.setChartSeriesTrendline(chart, params.seriesIndex, params.trendline);
-  }
-  if (params.errorBars !== void 0) {
-    pptxViewerCore.setChartSeriesErrorBars(chart, params.seriesIndex, params.errorBars);
-  }
-  return { pptxData: ctx.pptxData, dirty: true, result: { elementId: params.elementId } };
-}
-function setChartHelperLineT(ctx, params) {
-  const chart = findChartElement(ctx, params.slideIndex, params.elementId);
-  pptxViewerCore.setChartHelperLine(chart, params.line, params.style);
-  return { pptxData: ctx.pptxData, dirty: true, result: { elementId: params.elementId } };
-}
-function setChartColorMapOverrideT(ctx, params) {
-  const chart = findChartElement(ctx, params.slideIndex, params.elementId);
-  pptxViewerCore.setChartColorMapOverride(chart, params.overrides);
-  return { pptxData: ctx.pptxData, dirty: true, result: { elementId: params.elementId } };
-}
-
-// src/tools/chart-pareto.ts
-function cumulativePercent(values) {
-  const total = values.reduce((sum, value) => sum + value, 0);
-  if (total === 0) {
-    return values.map(() => 0);
-  }
-  let running = 0;
-  return values.map((value) => {
-    running += value;
-    return Math.round(running / total * 1e4) / 100;
-  });
-}
-function applyParetoChartTypeAlias(chart, requestedType) {
-  if (requestedType.trim().toLowerCase() !== "pareto" || !chart.chartData) {
-    return;
-  }
-  const data = chart.chartData;
-  data.chartType = "histogram";
-  const [frequency] = data.series;
-  if (!frequency) {
-    return;
-  }
-  frequency.histogramOptions = { ...frequency.histogramOptions, layout: "histogram" };
-  const hasParetoLine = data.series.some((s) => s.histogramOptions?.layout === "pareto");
-  if (!hasParetoLine) {
-    data.series.push({
-      name: "Cumulative %",
-      values: cumulativePercent(frequency.values),
-      histogramOptions: { layout: "pareto" }
-    });
-  }
-}
-
-// 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);
-    applyParetoChartTypeAlias(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();
-  applyParetoChartTypeAlias(chart, params.chartType);
-  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 findChartElement2(ctx, slideIndex, elementId) {
-  const err = validateSlideIndex(slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[slideIndex];
-  const el = slide.elements.find((e) => e.id === elementId);
-  if (!el) {
-    throw new Error(`Element '${elementId}' not found on slide ${slideIndex}.`);
-  }
-  if (el.type !== "chart") {
-    throw new Error(`Element '${elementId}' is not a chart.`);
-  }
-  return el;
-}
-function buildShape(input) {
-  return {
-    kind: input.kind ?? "sp",
-    anchor: input.anchor ?? "rel",
-    from: input.from,
-    ...input.to ? { to: input.to } : {},
-    ...input.ext ? { ext: input.ext } : {},
-    ...input.prst ? { prst: input.prst } : {},
-    ...input.fill ? { fill: input.fill } : {},
-    ...input.stroke ? { stroke: input.stroke } : {},
-    ...input.strokeWidth !== void 0 ? { strokeWidth: input.strokeWidth } : {},
-    ...input.text ? { paragraphs: [{ text: input.text, align: "ctr" }] } : {}
-  };
-}
-function listChartUserShapesT(ctx, params) {
-  const chart = findChartElement2(ctx, params.slideIndex, params.elementId);
-  return { pptxData: ctx.pptxData, dirty: false, result: { shapes: pptxViewerCore.listChartUserShapes(chart) } };
-}
-function addChartUserShapeT(ctx, params) {
-  const chart = findChartElement2(ctx, params.slideIndex, params.elementId);
-  pptxViewerCore.addChartUserShape(chart, buildShape(params.shape));
-  const index = (chart.chartData?.userShapes?.length ?? 1) - 1;
-  return { pptxData: ctx.pptxData, dirty: true, result: { elementId: params.elementId, index } };
-}
-function updateChartUserShapeT(ctx, params) {
-  const chart = findChartElement2(ctx, params.slideIndex, params.elementId);
-  const patch = {
-    ...params.patch.kind ? { kind: params.patch.kind } : {},
-    ...params.patch.anchor ? { anchor: params.patch.anchor } : {},
-    ...params.patch.from ? { from: params.patch.from } : {},
-    ...params.patch.to ? { to: params.patch.to } : {},
-    ...params.patch.ext ? { ext: params.patch.ext } : {},
-    ...params.patch.prst ? { prst: params.patch.prst } : {},
-    ...params.patch.fill ? { fill: params.patch.fill } : {},
-    ...params.patch.stroke ? { stroke: params.patch.stroke } : {},
-    ...params.patch.strokeWidth !== void 0 ? { strokeWidth: params.patch.strokeWidth } : {},
-    ...params.patch.text !== void 0 ? { paragraphs: [{ text: params.patch.text, align: "ctr" }] } : {}
-  };
-  pptxViewerCore.updateChartUserShape(chart, params.index, patch);
-  return { pptxData: ctx.pptxData, dirty: true, result: { elementId: params.elementId } };
-}
-function removeChartUserShapeT(ctx, params) {
-  const chart = findChartElement2(ctx, params.slideIndex, params.elementId);
-  pptxViewerCore.removeChartUserShape(chart, params.index);
-  return { pptxData: ctx.pptxData, dirty: true, result: { elementId: params.elementId } };
-}
-
-// src/tools/text-editing.ts
-function editRange(segments, start, end, replacement) {
-  let offset = 0;
-  let inserted = false;
-  for (const segment of segments) {
-    const text = segment.text;
-    const next = offset + text.length;
-    if (!segment.bulletInfo?.ownedByParagraph && next > start && offset < end) {
-      const from = Math.max(0, start - offset);
-      const to = Math.min(text.length, end - offset);
-      segment.text = text.slice(0, from) + (inserted ? "" : replacement) + text.slice(to);
-      inserted = true;
-    } else if (!inserted && start === end && offset <= start && next >= start && !segment.bulletInfo?.ownedByParagraph) {
-      const at = start - offset;
-      segment.text = text.slice(0, at) + replacement + text.slice(at);
-      inserted = true;
-    }
-    offset = next;
-  }
-  if (!inserted && replacement) {
-    segments.push({ text: replacement, style: {} });
-  }
-}
-function changedRange(before, text) {
-  let start = 0;
-  while (start < before.length && start < text.length && before[start] === text[start]) {
-    start++;
-  }
-  let suffix = 0;
-  while (suffix < before.length - start && suffix < text.length - start && before[before.length - suffix - 1] === text[text.length - suffix - 1]) {
-    suffix++;
-  }
-  return {
-    start,
-    end: before.length - suffix,
-    replacement: text.slice(start, text.length - suffix)
-  };
-}
-function setElementText(element, text) {
-  const segments = element.textSegments;
-  if (segments?.length) {
-    const before = segments.map((segment) => segment.text).join("");
-    const oldLines = before.split("\n");
-    const newLines = text.split("\n");
-    if (oldLines.length === newLines.length) {
-      let offset = before.length;
-      for (let index = oldLines.length - 1; index >= 0; index--) {
-        const line = oldLines[index];
-        offset -= line.length;
-        const edit = changedRange(line, newLines[index]);
-        editRange(segments, offset + edit.start, offset + edit.end, edit.replacement);
-        offset--;
-      }
-    } else {
-      const edit = changedRange(before, text);
-      editRange(segments, edit.start, edit.end, edit.replacement);
-    }
-    element.text = segments.map((segment) => segment.text).join("");
-  } else {
-    element.text = text;
-  }
-}
-function replaceElementText(element, regex, replacement) {
-  const before = element.text ?? element.textSegments?.map((segment) => segment.text).join("") ?? "";
-  const matches = Array.from(before.matchAll(regex));
-  if (before.replace(regex, replacement) === before) {
-    return 0;
-  }
-  if (!element.textSegments?.length) {
-    element.text = before.replace(regex, replacement);
-    return matches.length;
-  }
-  for (const match of matches.reverse()) {
-    const start = match.index;
-    const end = start + match[0].length;
-    const single = new RegExp(regex.source, `${regex.flags.replace("g", "")}y`);
-    single.lastIndex = start;
-    const after = before.replace(single, replacement);
-    editRange(
-      element.textSegments,
-      start,
-      end,
-      after.slice(start, after.length - (before.length - end))
-    );
-  }
-  element.text = element.textSegments.map((segment) => segment.text).join("");
-  return matches.length;
-}
-
-// src/tools/content-tools.ts
-var MAX_REGEX_LEN = 200;
-function hasNestedUnboundedQuantifier(pattern) {
-  return /\([^)]*[+*]\)[+*]/u.test(pattern);
-}
-function buildSearchRegex(query, useRegex, caseSensitive) {
-  if (useRegex) {
-    if (query.length > MAX_REGEX_LEN) {
-      return null;
-    }
-    if (hasNestedUnboundedQuantifier(query)) {
-      return null;
-    }
-  }
-  const pattern = useRegex ? query : query.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-  const flags = caseSensitive ? "g" : "gi";
-  try {
-    return new RegExp(pattern, flags);
-  } catch {
-    return null;
-  }
-}
-function findText(ctx, params) {
-  const regex = buildSearchRegex(
-    params.query,
-    params.useRegex === true,
-    params.caseSensitive === true
-  );
-  if (!regex) {
-    return {
-      pptxData: ctx.pptxData,
-      dirty: false,
-      result: { query: params.query, matchCount: 0, matches: [] }
-    };
-  }
-  const targetIndexes = params.slideIndexes ? params.slideIndexes : ctx.pptxData.slides.map((_, i) => i);
-  const matches = [];
-  for (const si of targetIndexes) {
-    const err = validateSlideIndex(si, ctx.pptxData.slides.length);
-    if (err) {
-      throw new Error(err);
-    }
-    const slide = ctx.pptxData.slides[si];
-    for (const el of slide.elements) {
-      if (pptxViewerCore.hasTextProperties(el)) {
-        const textEl = el;
-        if (textEl.text) {
-          const localMatches = Array.from(textEl.text.matchAll(regex));
-          for (const m of localMatches) {
-            matches.push({
-              slideIndex: si,
-              elementId: el.id,
-              elementType: el.type,
-              matchedText: m[0],
-              context: textEl.text.slice(
-                Math.max(0, (m.index ?? 0) - 20),
-                (m.index ?? 0) + m[0].length + 20
-              )
-            });
-          }
-        }
-      }
-      if (el.type === "table") {
-        const tbl = el;
-        if (tbl.tableData) {
-          for (const row of tbl.tableData.rows) {
-            for (const cell of row.cells) {
-              if (cell.text) {
-                const localMatches = Array.from(cell.text.matchAll(regex));
-                for (const m of localMatches) {
-                  matches.push({
-                    slideIndex: si,
-                    elementId: el.id,
-                    elementType: "table-cell",
-                    matchedText: m[0],
-                    context: cell.text.slice(
-                      Math.max(0, (m.index ?? 0) - 20),
-                      (m.index ?? 0) + m[0].length + 20
-                    )
-                  });
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    if (slide.notes) {
-      const noteMatches = Array.from(slide.notes.matchAll(regex));
-      for (const m of noteMatches) {
-        matches.push({
-          slideIndex: si,
-          elementId: "notes",
-          elementType: "notes",
-          matchedText: m[0],
-          context: slide.notes.slice(
-            Math.max(0, (m.index ?? 0) - 20),
-            (m.index ?? 0) + m[0].length + 20
-          )
-        });
-      }
-    }
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: false,
-    result: {
-      query: params.query,
-      matchCount: matches.length,
-      matches
-    }
-  };
-}
-function replaceText(ctx, params) {
-  const regex = buildSearchRegex(
-    params.query,
-    params.useRegex === true,
-    params.caseSensitive === true
-  );
-  if (!regex) {
-    return {
-      pptxData: ctx.pptxData,
-      dirty: false,
-      result: { query: params.query, replacement: params.replacement, replacementCount: 0 }
-    };
-  }
-  const targetIndexes = params.slideIndexes ? params.slideIndexes : ctx.pptxData.slides.map((_, i) => i);
-  let count = 0;
-  for (const si of targetIndexes) {
-    const err = validateSlideIndex(si, ctx.pptxData.slides.length);
-    if (err) {
-      throw new Error(err);
-    }
-    const slide = ctx.pptxData.slides[si];
-    for (const el of slide.elements) {
-      if (pptxViewerCore.hasTextProperties(el)) {
-        const textEl = el;
-        if (textEl.text) {
-          const before = textEl.text;
-          const after = before.replace(regex, params.replacement);
-          if (after !== before) {
-            const matchCount = Array.from(before.matchAll(regex)).length;
-            count += matchCount;
-            replaceElementText(textEl, regex, params.replacement);
-          }
-        }
-      }
-      if (el.type === "table") {
-        const tbl = el;
-        if (tbl.tableData) {
-          for (const row of tbl.tableData.rows) {
-            for (const cell of row.cells) {
-              if (cell.text) {
-                const before = cell.text;
-                const after = before.replace(regex, params.replacement);
-                if (after !== before) {
-                  count += Array.from(before.matchAll(regex)).length;
-                  cell.text = after;
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    if (slide.notes) {
-      const before = slide.notes;
-      const after = before.replace(regex, params.replacement);
-      if (after !== before) {
-        count += Array.from(before.matchAll(regex)).length;
-        slide.notes = after;
-      }
-    }
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: count > 0,
-    result: {
-      query: params.query,
-      replacement: params.replacement,
-      replacementCount: count
-    }
-  };
-}
-function manageComments(ctx, params) {
-  switch (params.action) {
-    case "list": {
-      const all = [];
-      for (let si = 0; si < ctx.pptxData.slides.length; si++) {
-        if (params.slideIndex !== void 0 && si !== params.slideIndex) {
-          continue;
-        }
-        const slide = ctx.pptxData.slides[si];
-        for (const c of slide.comments ?? []) {
-          if (!params.includeResolved && c.resolved) {
-            continue;
-          }
-          all.push({
-            id: c.id,
-            slideIndex: si,
-            text: c.text,
-            author: c.author,
-            createdAt: c.createdAt,
-            resolved: c.resolved
-          });
-        }
-      }
-      return {
-        pptxData: ctx.pptxData,
-        dirty: false,
-        result: { action: "list", comments: all, count: all.length }
-      };
-    }
-    case "add": {
-      if (params.slideIndex === void 0) {
-        throw new Error("slideIndex is required for add action.");
-      }
-      const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-      if (err) {
-        throw new Error(err);
-      }
-      if (!params.text) {
-        throw new Error("text is required for add action.");
-      }
-      const slide = ctx.pptxData.slides[params.slideIndex];
-      if (!slide.comments) {
-        slide.comments = [];
-      }
-      const newId = `comment-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      slide.comments.push({
-        id: newId,
-        text: params.text,
-        author: params.author,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        resolved: false
-      });
-      return {
-        pptxData: ctx.pptxData,
-        dirty: true,
-        result: { action: "add", commentId: newId }
-      };
-    }
-    case "delete": {
-      if (!params.commentId) {
-        throw new Error("commentId is required for delete action.");
-      }
-      let deleted = false;
-      for (const slide of ctx.pptxData.slides) {
-        if (!slide.comments) {
-          continue;
-        }
-        const before = slide.comments.length;
-        slide.comments = slide.comments.filter((c) => c.id !== params.commentId);
-        if (slide.comments.length < before) {
-          deleted = true;
-          break;
-        }
-      }
-      if (!deleted) {
-        throw new Error(`Comment '${params.commentId}' not found.`);
-      }
-      return {
-        pptxData: ctx.pptxData,
-        dirty: true,
-        result: { action: "delete", commentId: params.commentId }
-      };
-    }
-    case "resolve": {
-      if (!params.commentId) {
-        throw new Error("commentId is required for resolve action.");
-      }
-      let found = false;
-      for (const slide of ctx.pptxData.slides) {
-        const comment = slide.comments?.find((c) => c.id === params.commentId);
-        if (comment) {
-          comment.resolved = params.resolved !== false;
-          found = true;
-          break;
-        }
-      }
-      if (!found) {
-        throw new Error(`Comment '${params.commentId}' not found.`);
-      }
-      return {
-        pptxData: ctx.pptxData,
-        dirty: true,
-        result: { action: "resolve", commentId: params.commentId }
-      };
-    }
-    default: {
-      throw new Error(`Unknown action: ${String(params.action)}`);
-    }
-  }
-}
-async function convertToMarkdown(ctx, params) {
-  const options = {
-    mediaFolderName: params.mediaFolderName ?? "media",
-    includeMetadata: params.includeMetadata !== false,
-    slideRange: params.slideRange,
-    includeSpeakerNotes: params.includeSpeakerNotes !== false,
-    semanticMode: params.semanticMode === true,
-    sourceName: params.sourceName ?? "unknown"
-  };
-  const outputDir = params.outputDir ?? ".";
-  const safeOutputDir = params.scopeOutputDir ? params.scopeOutputDir(outputDir, params.rootDir) : outputDir;
-  const converter = new pptxViewerCore.PptxMarkdownConverter(safeOutputDir, options);
-  const markdown = await converter.convert(ctx.pptxData);
-  return {
-    pptxData: ctx.pptxData,
-    dirty: false,
-    result: {
-      markdown,
-      slidesConverted: converter.slidesConverted,
-      totalSlides: converter.presentationSlides,
-      imagesExtracted: converter.imagesExtracted
-    }
-  };
-}
-var ALT_TEXT_ELEMENT_TYPES = /* @__PURE__ */ new Set(["image", "picture", "table", "chart", "smartArt", "ole", "media", "text", "shape", "connector"]);
-var TITLE_ELEMENT_TYPES = /* @__PURE__ */ new Set([
-  "table",
-  "chart",
-  "smartArt",
-  "ole",
-  "media",
-  "text",
-  "shape",
-  "connector"
-]);
-function applyElementAltText(el, altText) {
-  if (!ALT_TEXT_ELEMENT_TYPES.has(el.type)) {
-    throw new Error(
-      `Element '${el.id}' (${el.type}) does not support altText; only ${[...ALT_TEXT_ELEMENT_TYPES].join(", ")} elements do.`
-    );
-  }
-  el.altText = altText;
-}
-function applyElementTitle(el, title) {
-  if (!TITLE_ELEMENT_TYPES.has(el.type)) {
-    throw new Error(
-      `Element '${el.id}' (${el.type}) does not support title; only ${[...TITLE_ELEMENT_TYPES].join(", ")} elements do.`
-    );
-  }
-  el.title = title;
-}
-function updateElementStyle(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  const el = slide.elements.find((e) => e.id === params.elementId);
-  if (!el) {
-    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
-  }
-  if ("shapeStyle" in el) {
-    if (!el.shapeStyle) {
-      el.shapeStyle = {};
-    }
-    const ss = el.shapeStyle;
-    if (params.fillThemeColor !== void 0) {
-      ss.fillColorRef = params.fillThemeColor;
-      const resolved = pptxViewerCore.resolveThemeColorRef(params.fillThemeColor, ctx.pptxData.themeColorMap);
-      if (params.fillColor !== void 0) {
-        ss.fillColor = params.fillColor;
-      } else if (resolved) {
-        ss.fillColor = resolved;
-      }
-    } else if (params.fillColor !== void 0) {
-      ss.fillColor = params.fillColor;
-      ss.fillColorRef = void 0;
-    }
-    if (params.fillMode !== void 0) {
-      ss.fillMode = params.fillMode;
-    }
-    if (params.fillGradientStops !== void 0) {
-      ss.fillGradientStops = params.fillGradientStops;
-    }
-    if (params.fillGradientAngle !== void 0) {
-      ss.fillGradientAngle = params.fillGradientAngle;
-    }
-    if (params.fillGradientType !== void 0) {
-      ss.fillGradientType = params.fillGradientType;
-    }
-    if (params.fillOpacity !== void 0) {
-      ss.fillOpacity = params.fillOpacity;
-    }
-    if (params.strokeThemeColor !== void 0) {
-      ss.strokeColorRef = params.strokeThemeColor;
-      const resolved = pptxViewerCore.resolveThemeColorRef(params.strokeThemeColor, ctx.pptxData.themeColorMap);
-      if (params.strokeColor !== void 0) {
-        ss.strokeColor = params.strokeColor;
-      } else if (resolved) {
-        ss.strokeColor = resolved;
-      }
-    } else if (params.strokeColor !== void 0) {
-      ss.strokeColor = params.strokeColor;
-      ss.strokeColorRef = void 0;
-    }
-    if (params.strokeWidth !== void 0) {
-      ss.strokeWidth = params.strokeWidth;
-    }
-    if (params.strokeDash !== void 0) {
-      ss.strokeDash = params.strokeDash;
-    }
-    if (params.strokeOpacity !== void 0) {
-      ss.strokeOpacity = params.strokeOpacity;
-    }
-    if (params.shadowColor !== void 0) {
-      ss.shadowColor = params.shadowColor;
-    }
-    if (params.shadowBlur !== void 0) {
-      ss.shadowBlur = params.shadowBlur;
-    }
-    if (params.shadowOffsetX !== void 0) {
-      ss.shadowOffsetX = params.shadowOffsetX;
-    }
-    if (params.shadowOffsetY !== void 0) {
-      ss.shadowOffsetY = params.shadowOffsetY;
-    }
-    if (params.shadowOpacity !== void 0) {
-      ss.shadowOpacity = params.shadowOpacity;
-    }
-    if (params.glowColor !== void 0) {
-      ss.glowColor = params.glowColor;
-    }
-    if (params.glowRadius !== void 0) {
-      ss.glowRadius = params.glowRadius;
-    }
-    if (params.glowOpacity !== void 0) {
-      ss.glowOpacity = params.glowOpacity;
-    }
-    if (params.softEdgeRadius !== void 0) {
-      ss.softEdgeRadius = params.softEdgeRadius;
-    }
-  }
-  if (params.altText !== void 0) {
-    applyElementAltText(el, params.altText);
-  }
-  if (params.title !== void 0) {
-    applyElementTitle(el, params.title);
-  }
-  if (el.type === "image" || el.type === "picture") {
-    const img = el;
-    if (params.cropLeft !== void 0) {
-      img.cropLeft = params.cropLeft;
-    }
-    if (params.cropTop !== void 0) {
-      img.cropTop = params.cropTop;
-    }
-    if (params.cropRight !== void 0) {
-      img.cropRight = params.cropRight;
-    }
-    if (params.cropBottom !== void 0) {
-      img.cropBottom = params.cropBottom;
-    }
-    if (params.brightness !== void 0 || params.contrast !== void 0 || params.grayscale !== void 0) {
-      if (!img.imageEffects) {
-        img.imageEffects = {};
-      }
-      if (params.brightness !== void 0) {
-        img.imageEffects.brightness = params.brightness;
-      }
-      if (params.contrast !== void 0) {
-        img.imageEffects.contrast = params.contrast;
-      }
-      if (params.grayscale !== void 0) {
-        img.imageEffects.grayscale = params.grayscale;
-      }
-    }
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { elementId: params.elementId }
-  };
-}
-function runAccessibilityCheck(ctx) {
-  const issues = [];
-  for (let si = 0; si < ctx.pptxData.slides.length; si++) {
-    const slide = ctx.pptxData.slides[si];
-    let slideHasText = false;
-    for (const el of slide.elements) {
-      if (el.type === "image" || el.type === "picture") {
-        const img = el;
-        if (!img.altText) {
-          issues.push({
-            slideIndex: si,
-            elementId: el.id,
-            severity: "error",
-            message: `Image element '${el.id}' has no alt text.`
-          });
-        }
-      }
-      if (pptxViewerCore.hasTextProperties(el)) {
-        const textEl = el;
-        slideHasText = true;
-        if (!textEl.text || textEl.text.trim() === "") {
-          issues.push({
-            slideIndex: si,
-            elementId: el.id,
-            severity: "info",
-            message: `Text element '${el.id}' is empty.`
-          });
-        }
-        const fs = textEl.textStyle?.fontSize;
-        if (fs !== void 0 && fs < 10) {
-          issues.push({
-            slideIndex: si,
-            elementId: el.id,
-            severity: "warning",
-            message: `Text element '${el.id}' has very small font size (${fs}pt < 10pt).`
-          });
-        }
-        const textColor = textEl.textStyle?.color?.toLowerCase();
-        const bgColor = slide.backgroundColor?.toLowerCase();
-        if (textColor && bgColor && textColor === bgColor) {
-          issues.push({
-            slideIndex: si,
-            elementId: el.id,
-            severity: "error",
-            message: `Text element '${el.id}' has same color as slide background (${textColor}).`
-          });
-        }
-      }
-    }
-    if (!slideHasText) {
-      issues.push({
-        slideIndex: si,
-        severity: "warning",
-        message: `Slide ${si + 1} contains no text elements.`
-      });
-    }
-  }
-  const errorCount = issues.filter((i) => i.severity === "error").length;
-  const warningCount = issues.filter((i) => i.severity === "warning").length;
-  const infoCount = issues.filter((i) => i.severity === "info").length;
-  return {
-    pptxData: ctx.pptxData,
-    dirty: false,
-    result: {
-      slideCount: ctx.pptxData.slides.length,
-      totalIssues: issues.length,
-      errorCount,
-      warningCount,
-      infoCount,
-      issues
-    }
-  };
-}
-
-// src/tools/element-tools.ts
-function addElement(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  const id = generateElementId();
-  const x = params.x ?? 100;
-  const y = params.y ?? 100;
-  const width = params.width ?? 300;
-  const height = params.height ?? 60;
-  switch (params.type) {
-    case "text": {
-      const el = {
-        id,
-        type: "text",
-        x,
-        y,
-        width,
-        height,
-        text: params.text ?? "",
-        textStyle: {
-          fontSize: params.fontSize,
-          fontFamily: params.fontFamily,
-          color: params.fontColor,
-          bold: params.bold,
-          italic: params.italic,
-          underline: params.underline,
-          align: params.alignment
-        },
-        textSegments: [
-          {
-            text: params.text ?? "",
-            style: {
-              fontSize: params.fontSize,
-              fontFamily: params.fontFamily,
-              color: params.fontColor,
-              bold: params.bold,
-              italic: params.italic,
-              underline: params.underline
-            }
-          }
-        ]
-      };
-      slide.elements.push(el);
-      break;
-    }
-    case "shape": {
-      const el = {
-        id,
-        type: "shape",
-        x,
-        y,
-        width,
-        height,
-        shapeType: params.shapeType ?? "rect",
-        text: params.text,
-        textStyle: params.text ? {
-          fontSize: params.fontSize,
-          fontFamily: params.fontFamily,
-          color: params.fontColor,
-          bold: params.bold,
-          italic: params.italic,
-          align: params.alignment
-        } : void 0,
-        shapeStyle: {
-          fillColor: params.fillColor,
-          strokeColor: params.strokeColor,
-          strokeWidth: params.strokeWidth
-        }
-      };
-      slide.elements.push(el);
-      break;
-    }
-    case "image": {
-      const el = {
-        id,
-        type: "image",
-        x,
-        y,
-        width,
-        height,
-        imageData: params.imageData,
-        altText: params.altText
-      };
-      slide.elements.push(el);
-      break;
-    }
-    case "table": {
-      const rowCount = params.rows ?? 2;
-      const colCount = params.columns ?? 2;
-      const colWidth = 1 / colCount;
-      const tableRows = Array.from({ length: rowCount }, (_, r) => ({
-        height: 40,
-        cells: Array.from({ length: colCount }, (__, c) => ({
-          text: params.cellData?.[r]?.[c] ?? ""
-        }))
-      }));
-      const tableEl = {
-        id,
-        type: "table",
-        x,
-        y,
-        width,
-        height: params.height ?? rowCount * 40,
-        tableData: {
-          rows: tableRows,
-          columnWidths: Array.from({ length: colCount }, () => colWidth),
-          firstRowHeader: params.headerRow ?? false
-        }
-      };
-      slide.elements.push(tableEl);
-      break;
-    }
-    case "connector": {
-      const el = {
-        id,
-        type: "connector",
-        x,
-        y,
-        width,
-        height,
-        shapeStyle: {
-          strokeColor: params.strokeColor ?? "#000000",
-          strokeWidth: params.strokeWidth ?? 1,
-          connectorStartArrow: params.startArrow,
-          connectorEndArrow: params.endArrow
-        }
-      };
-      slide.elements.push(el);
-      break;
-    }
-    default: {
-      throw new Error(`Unknown element type: ${String(params.type)}`);
-    }
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { elementId: id, slideIndex: params.slideIndex }
-  };
-}
-function updateElement(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  const el = slide.elements.find((e) => e.id === params.elementId);
-  if (!el) {
-    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
-  }
-  if (params.x !== void 0) {
-    el.x = params.x;
-  }
-  if (params.y !== void 0) {
-    el.y = params.y;
-  }
-  if (params.width !== void 0) {
-    el.width = params.width;
-  }
-  if (params.height !== void 0) {
-    el.height = params.height;
-  }
-  if (params.rotation !== void 0) {
-    el.rotation = params.rotation;
-  }
-  if (params.opacity !== void 0) {
-    el.opacity = params.opacity;
-  }
-  if (params.hidden !== void 0) {
-    el.hidden = params.hidden;
-  }
-  if (params.flipH !== void 0) {
-    el.flipHorizontal = params.flipH;
-  }
-  if (params.flipV !== void 0) {
-    el.flipVertical = params.flipV;
-  }
-  if (params.altText !== void 0) {
-    applyElementAltText(el, params.altText);
-  }
-  if (params.title !== void 0) {
-    applyElementTitle(el, params.title);
-  }
-  if (pptxViewerCore.hasTextProperties(el)) {
-    const textEl = el;
-    if (params.textSegments !== void 0) {
-      textEl.textSegments = structuredClone(params.textSegments);
-      textEl.text = textEl.textSegments.map((segment) => segment.text).join("");
-    } else if (params.text !== void 0) {
-      setElementText(textEl, params.text);
-    }
-    if (!textEl.textStyle) {
-      textEl.textStyle = {};
-    }
-    if (params.fontSize !== void 0) {
-      textEl.textStyle.fontSize = params.fontSize;
-    }
-    if (params.fontFamily !== void 0) {
-      textEl.textStyle.fontFamily = params.fontFamily;
-    }
-    if (params.fontThemeColor !== void 0) {
-      textEl.textStyle.colorRef = params.fontThemeColor;
-      const resolved = pptxViewerCore.resolveThemeColorRef(params.fontThemeColor, ctx.pptxData.themeColorMap);
-      if (params.fontColor !== void 0) {
-        textEl.textStyle.color = params.fontColor;
-      } else if (resolved) {
-        textEl.textStyle.color = resolved;
-      }
-    } else if (params.fontColor !== void 0) {
-      textEl.textStyle.color = params.fontColor;
-      textEl.textStyle.colorRef = void 0;
-    }
-    if (params.bold !== void 0) {
-      textEl.textStyle.bold = params.bold;
-    }
-    if (params.italic !== void 0) {
-      textEl.textStyle.italic = params.italic;
-    }
-    if (params.underline !== void 0) {
-      textEl.textStyle.underline = params.underline;
-    }
-    if (params.alignment !== void 0) {
-      textEl.textStyle.align = params.alignment;
-    }
-  }
-  if ("shapeStyle" in el && el.shapeStyle) {
-    const ss = el.shapeStyle;
-    if (params.fillColor !== void 0) {
-      ss.fillColor = params.fillColor;
-    }
-    if (params.strokeColor !== void 0) {
-      ss.strokeColor = params.strokeColor;
-    }
-    if (params.strokeWidth !== void 0) {
-      ss.strokeWidth = params.strokeWidth;
-    }
-  } else if (params.fillColor !== void 0 || params.strokeColor !== void 0 || params.strokeWidth !== void 0) {
-    if ("shapeStyle" in el) {
-      el.shapeStyle = {
-        fillColor: params.fillColor,
-        strokeColor: params.strokeColor,
-        strokeWidth: params.strokeWidth
-      };
-    }
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { elementId: params.elementId }
-  };
-}
-function renameElement(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}.`);
-  }
-  const name = params.name.trim();
-  if (name.length === 0) {
-    delete el.name;
-  } else {
-    el.name = name;
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { elementId: params.elementId, name }
-  };
-}
-function deleteElements(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  const idSet = new Set(params.elementIds);
-  const existingIds = new Set(slide.elements.map((element) => element.id));
-  const notFound = params.elementIds.filter((id) => !existingIds.has(id));
-  if (notFound.length > 0) {
-    throw new Error(`Elements not found: ${notFound.join(", ")}`);
-  }
-  const before = slide.elements.length;
-  slide.elements = slide.elements.filter((e) => !idSet.has(e.id));
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { deletedCount: before - slide.elements.length }
-  };
-}
-function arrangeElements(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  if (params.action === "align") {
-    if (!params.elementIds || params.elementIds.length === 0) {
-      throw new Error("elementIds is required for align action.");
-    }
-    const targetIds = new Set(params.elementIds);
-    const targets = slide.elements.filter((element) => targetIds.has(element.id));
-    if (targets.length === 0) {
-      throw new Error("No matching elements found for align.");
-    }
-    switch (params.alignment) {
-      case "left": {
-        const minX = Math.min(...targets.map((e) => e.x));
-        for (const t of targets) {
-          t.x = minX;
-        }
-        break;
-      }
-      case "right": {
-        const maxRight = Math.max(...targets.map((e) => e.x + e.width));
-        for (const t of targets) {
-          t.x = maxRight - t.width;
-        }
-        break;
-      }
-      case "top": {
-        const minY = Math.min(...targets.map((e) => e.y));
-        for (const t of targets) {
-          t.y = minY;
-        }
-        break;
-      }
-      case "bottom": {
-        const maxBottom = Math.max(...targets.map((e) => e.y + e.height));
-        for (const t of targets) {
-          t.y = maxBottom - t.height;
-        }
-        break;
-      }
-      case "centerH": {
-        const avgCX = targets.reduce((s, e) => s + e.x + e.width / 2, 0) / targets.length;
-        for (const t of targets) {
-          t.x = avgCX - t.width / 2;
-        }
-        break;
-      }
-      case "centerV": {
-        const avgCY = targets.reduce((s, e) => s + e.y + e.height / 2, 0) / targets.length;
-        for (const t of targets) {
-          t.y = avgCY - t.height / 2;
-        }
-        break;
-      }
-      default: {
-        throw new Error(`Unknown alignment: ${String(params.alignment)}`);
-      }
-    }
-  } else if (params.action === "reorderLayer") {
-    if (!params.elementId) {
-      throw new Error("elementId is required for reorderLayer action.");
-    }
-    const idx = slide.elements.findIndex((e) => e.id === params.elementId);
-    if (idx < 0) {
-      throw new Error(`Element '${params.elementId}' not found.`);
-    }
-    const [el] = slide.elements.splice(idx, 1);
-    switch (params.layerAction) {
-      case "bringToFront":
-        slide.elements.push(el);
-        break;
-      case "sendToBack":
-        slide.elements.unshift(el);
-        break;
-      case "bringForward": {
-        const newIdx = Math.min(idx + 1, slide.elements.length);
-        slide.elements.splice(newIdx, 0, el);
-        break;
-      }
-      case "sendBackward": {
-        const newIdx = Math.max(idx - 1, 0);
-        slide.elements.splice(newIdx, 0, el);
-        break;
-      }
-      default: {
-        slide.elements.splice(idx, 0, el);
-        throw new Error(`Unknown layerAction: ${String(params.layerAction)}`);
-      }
-    }
-  } else {
-    throw new Error(`Unknown action: ${String(params.action)}`);
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { slideIndex: params.slideIndex }
-  };
-}
-function cloneElement(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const srcSlide = ctx.pptxData.slides[params.slideIndex];
-  const original = srcSlide.elements.find((e) => e.id === params.elementId);
-  if (!original) {
-    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
-  }
-  const targets = params.targetSlideIndexes ?? [params.slideIndex];
-  const clonedIds = [];
-  const offsetX = params.offsetX ?? 20;
-  const offsetY = params.offsetY ?? 20;
-  for (const targetIdx of targets) {
-    const terr = validateSlideIndex(targetIdx, ctx.pptxData.slides.length);
-    if (terr) {
-      throw new Error(terr);
-    }
-    const clone = pptxViewerCore.cloneElement(original);
-    const intoTemplate = pptxViewerCore.isTemplateElementId(original.id);
-    clone.id = pptxViewerCore.makeStoreAwareId(intoTemplate, original.id);
-    pptxViewerCore.reassignDescendantIds(clone, () => pptxViewerCore.makeStoreAwareId(intoTemplate, original.id));
-    clone.x += offsetX;
-    clone.y += offsetY;
-    ctx.pptxData.slides[targetIdx].elements.push(clone);
-    clonedIds.push(clone.id);
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { clonedIds }
-  };
-}
-function setElementAnimation(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  const elExists = slide.elements.some((e) => e.id === params.elementId);
-  if (!elExists) {
-    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
-  }
-  if (!slide.animations) {
-    slide.animations = [];
-  }
-  const existing = slide.animations.find((a) => a.elementId === params.elementId);
-  if (existing) {
-    if (params.entrance !== void 0) {
-      existing.entrance = params.entrance;
-    }
-    if (params.exit !== void 0) {
-      existing.exit = params.exit;
-    }
-    if (params.durationMs !== void 0) {
-      existing.durationMs = params.durationMs;
-    }
-    if (params.delayMs !== void 0) {
-      existing.delayMs = params.delayMs;
-    }
-    if (params.order !== void 0) {
-      existing.order = params.order;
-    }
-  } else {
-    const anim = {
-      elementId: params.elementId,
-      entrance: params.entrance,
-      exit: params.exit,
-      durationMs: params.durationMs,
-      delayMs: params.delayMs,
-      order: params.order
-    };
-    slide.animations.push(anim);
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { elementId: params.elementId }
-  };
-}
-function groupElements(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  if (params.elementIds.length < 2) {
-    throw new Error("At least 2 elements are required to form a group.");
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  const idSet = new Set(params.elementIds);
-  const found = new Set(slide.elements.filter((e) => idSet.has(e.id)).map((e) => e.id));
-  if (found.size !== idSet.size) {
-    const missing = params.elementIds.filter((id) => !found.has(id));
-    throw new Error(`Elements not found: ${missing.join(", ")}`);
-  }
-  const groupId = generateElementId();
-  const grouped = pptxViewerCore.groupElements(slide.elements, params.elementIds, groupId);
-  slide.elements = grouped.elements;
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { groupId: grouped.groupId ?? groupId }
-  };
-}
-function ungroupElements(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  const group = slide.elements.find((e) => e.id === params.groupElementId);
-  if (!group) {
-    throw new Error(`Group element '${params.groupElementId}' not found.`);
-  }
-  if (group.type !== "group") {
-    throw new Error(`Element '${params.groupElementId}' is not a group.`);
-  }
-  const intoTemplate = pptxViewerCore.isTemplateElementId(group.id);
-  const childIds = group.children.map(
-    (child) => pptxViewerCore.isTemplateElementId(child.id) === intoTemplate ? child.id : pptxViewerCore.makeStoreAwareId(intoTemplate, group.id)
-  );
-  const promoted = pptxViewerCore.ungroupElements(slide.elements, params.groupElementId, childIds, {
-    intoTemplate
-  });
-  slide.elements = promoted.elements;
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { restoredIds: promoted.childIds }
-  };
-}
-function batchUpdateElements(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  const idSet = new Set(params.elementIds);
-  let count = 0;
-  for (const el of slide.elements) {
-    if (!idSet.has(el.id)) {
-      continue;
-    }
-    if (params.x !== void 0) {
-      el.x = params.x;
-    }
-    if (params.y !== void 0) {
-      el.y = params.y;
-    }
-    if (params.width !== void 0) {
-      el.width = params.width;
-    }
-    if (params.height !== void 0) {
-      el.height = params.height;
-    }
-    if (params.rotation !== void 0) {
-      el.rotation = params.rotation;
-    }
-    if (params.opacity !== void 0) {
-      el.opacity = params.opacity;
-    }
-    if (params.hidden !== void 0) {
-      el.hidden = params.hidden;
-    }
-    count++;
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { updatedCount: count }
-  };
-}
-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 }
-  };
-}
-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.");
-}
-
-// 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 exportToJson(ctx, params) {
-  const document = pptxViewerCore.buildPptxJsonDocument(ctx.pptxData, { generator: "pptx-viewer-mcp" });
-  const json = JSON.stringify(document, null, params.pretty === false ? void 0 : 2);
-  return {
-    pptxData: ctx.pptxData,
-    dirty: false,
-    result: {
-      json,
-      slideCount: document.slideCount,
-      byteSize: new TextEncoder().encode(json).byteLength,
-      assets: document.assets
-    }
-  };
-}
-function importFromJson(ctx, params) {
-  const imported = pptxViewerCore.deserializePptxFromJson(params.json);
-  pptxViewerCore.applyImportedPptxData(ctx.pptxData, imported);
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: {
-      slideCount: ctx.pptxData.slides.length,
-      width: ctx.pptxData.width,
-      height: ctx.pptxData.height
-    }
-  };
-}
-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;
-  }
-  const master = ctx.pptxData.slideMasters?.find(
-    (candidate) => candidate.layouts?.some((definition2) => definition2.path === layout.path)
-  );
-  const definition = master?.layouts?.find((candidate) => candidate.path === layout.path);
-  for (const frame of definition?.placeholders ?? []) {
-    if (["dt", "ftr", "sldnum", "hdr"].includes(frame.type)) {
-      continue;
-    }
-    const ph = {
-      "@_type": frame.type === "ctrtitle" ? "ctrTitle" : frame.type,
-      ...frame.idx !== void 0 ? { "@_idx": frame.idx } : {}
-    };
-    if (slide.elements.some((element) => {
-      const nv = element.rawXml?.["p:nvSpPr"];
-      const nvPr = nv?.["p:nvPr"];
-      const existing = nvPr?.["p:ph"];
-      return element.placeholderType === frame.type && String(existing?.["@_idx"] ?? "0") === String(frame.idx ?? "0");
-    })) {
-      continue;
-    }
-    const inherited = master?.placeholders?.find(
-      (candidate) => candidate.type === frame.type && (candidate.idx ?? "0") === (frame.idx ?? "0")
-    ) ?? master?.placeholders?.find((candidate) => candidate.type === frame.type);
-    slide.elements.push({
-      id: generateElementId(),
-      type: "text",
-      placeholderType: frame.type,
-      x: frame.x ?? inherited?.x ?? 0,
-      y: frame.y ?? inherited?.y ?? 0,
-      width: frame.width ?? inherited?.width ?? ctx.pptxData.width,
-      height: frame.height ?? inherited?.height ?? ctx.pptxData.height,
-      text: "",
-      textSegments: [{ text: "", style: {} }],
-      rawXml: {
-        "p:nvSpPr": {
-          "p:cNvPr": { "@_name": frame.type },
-          "p:cNvSpPr": {},
-          "p:nvPr": { "p:ph": ph }
-        },
-        "p:spPr": {}
-      }
-    });
-  }
-  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 }
-  };
-}
-function resolveOleElement(ctx, slideIndex, elementId) {
-  const err = validateSlideIndex(slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[slideIndex];
-  const index = slide.elements.findIndex((e) => e.id === elementId);
-  if (index === -1) {
-    throw new Error(`Element '${elementId}' not found on slide ${slideIndex}.`);
-  }
-  const element = slide.elements[index];
-  if (element.type !== "ole") {
-    throw new Error(`Element '${elementId}' is not an OLE object.`);
-  }
-  return { slide, element, index };
-}
-function commitOleElement(slide, index, updated) {
-  slide.elements.splice(index, 1, updated);
-  slide.isDirty = true;
-}
-async function getOleContent(ctx, params) {
-  const { element } = resolveOleElement(ctx, params.slideIndex, params.elementId);
-  const kind = await pptxViewerCore.resolveOleEditorKindFromPayload(element);
-  const base = { pptxData: ctx.pptxData, dirty: false };
-  switch (kind) {
-    case "sheet-xlsx":
-    case "sheet-xls": {
-      const sheet = await pptxViewerCore.getOleSheetGrid(element);
-      return { ...base, result: { elementId: element.id, kind, editable: true, sheet } };
-    }
-    case "document-docx":
-    case "document-doc": {
-      const paragraphs = await pptxViewerCore.getOleDocumentParagraphs(element);
-      return { ...base, result: { elementId: element.id, kind, editable: true, paragraphs } };
-    }
-    case "deck-pptx": {
-      const deckSlides = await pptxViewerCore.getOleNestedDeckDetail(element);
-      return { ...base, result: { elementId: element.id, kind, editable: true, deckSlides } };
-    }
-    default:
-      return {
-        ...base,
-        result: {
-          elementId: element.id,
-          kind,
-          editable: false,
-          message: `This OLE object's content (${kind}) is not directly editable; use ole_replace_file to replace it wholesale.`
-        }
-      };
-  }
-}
-async function setOleSheetCell(ctx, params) {
-  const { slide, element, index } = resolveOleElement(ctx, params.slideIndex, params.elementId);
-  const updated = await pptxViewerCore.applyOleSheetCellEdit(element, {
-    row: params.row,
-    col: params.col,
-    value: params.value
-  });
-  const changed = updated !== element;
-  if (changed) {
-    commitOleElement(slide, index, updated);
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: changed,
-    result: { elementId: params.elementId, changed }
-  };
-}
-async function setOleDocumentParagraph(ctx, params) {
-  const { slide, element, index } = resolveOleElement(ctx, params.slideIndex, params.elementId);
-  const updated = await pptxViewerCore.applyOleDocumentParagraphEdit(element, params.paragraphIndex, params.text);
-  const changed = updated !== element;
-  if (changed) {
-    commitOleElement(slide, index, updated);
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: changed,
-    result: { elementId: params.elementId, changed }
-  };
-}
-async function setOleDeckSlideTitle(ctx, params) {
-  const { slide, element, index } = resolveOleElement(ctx, params.slideIndex, params.elementId);
-  const updated = await pptxViewerCore.applyOleNestedDeckElementTextEdit(
-    element,
-    params.deckSlideIndex,
-    params.deckElementId,
-    params.title
-  );
-  const changed = updated !== element;
-  if (changed) {
-    commitOleElement(slide, index, updated);
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: changed,
-    result: { elementId: params.elementId, changed }
-  };
-}
-async function setOleObjectNameT(ctx, params) {
-  const { slide, element, index } = resolveOleElement(ctx, params.slideIndex, params.elementId);
-  const updated = await pptxViewerCore.setOleObjectName(element, params.name);
-  commitOleElement(slide, index, updated);
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { elementId: params.elementId, changed: true }
-  };
-}
-async function replaceOleFileT(ctx, params) {
-  const { slide, element, index } = resolveOleElement(ctx, params.slideIndex, params.elementId);
-  const parsed = pptxViewerCore.parseDataUrlToBytes(params.fileData);
-  if (!parsed) {
-    throw new Error('fileData must be a base64 data URL, e.g. "data:<mime-type>;base64,<...>".');
-  }
-  const updated = await pptxViewerCore.replaceOleFile(element, parsed.bytes, params.fileName);
-  commitOleElement(slide, index, updated);
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { elementId: params.elementId, changed: true }
-  };
-}
-
-// 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) {
-    slide.backgroundGradient = params.backgroundGradient;
-  }
-  if (params.backgroundImage !== void 0) {
-    slide.backgroundImage = params.backgroundImage;
-  }
-  if (params.notes !== void 0) {
-    slide.notes = params.notes;
-  }
-  if (params.hidden !== void 0) {
-    slide.hidden = params.hidden;
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { slideIndex: params.slideIndex }
-  };
-}
-function setSlideTransition(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  if (params.type === "none") {
-    slide.transition = void 0;
-  } else {
-    const transition = {
-      type: params.type
-    };
-    if (params.durationMs !== void 0) {
-      transition.durationMs = params.durationMs;
-    }
-    if (params.direction !== void 0) {
-      transition.direction = params.direction;
-    }
-    if (params.advanceOnClick !== void 0) {
-      transition.advanceOnClick = params.advanceOnClick;
-    }
-    if (params.advanceAfterMs !== void 0) {
-      transition.advanceAfterMs = params.advanceAfterMs;
-    }
-    slide.transition = transition;
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { slideIndex: params.slideIndex, transitionType: params.type }
-  };
-}
-function setCanvasSize(ctx, params) {
-  ctx.pptxData.width = params.width;
-  ctx.pptxData.height = params.height;
-  if (ctx.pptxData.widthEmu !== void 0) {
-    ctx.pptxData.widthEmu = Math.round(params.width * 12700);
-  }
-  if (ctx.pptxData.heightEmu !== void 0) {
-    ctx.pptxData.heightEmu = Math.round(params.height * 12700);
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { canvasWidth: params.width, canvasHeight: params.height }
-  };
-}
-function 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 findTableElement(ctx, slideIndex, elementId) {
-  const err = validateSlideIndex(slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[slideIndex];
-  const el = slide.elements.find((e) => e.id === elementId);
-  if (!el) {
-    throw new Error(`Element '${elementId}' not found on slide ${slideIndex}.`);
-  }
-  if (el.type !== "table") {
-    throw new Error(`Element '${elementId}' is not a table.`);
-  }
-  return el;
-}
-function tableStyleIdsInUse(ctx) {
-  const used = /* @__PURE__ */ new Set();
-  for (const slide of ctx.pptxData.slides) {
-    for (const el of slide.elements) {
-      if (el.type === "table" && el.tableData?.tableStyleId) {
-        used.add(pptxViewerCore.normalizeTableStyleGuid(el.tableData.tableStyleId));
-      }
-    }
-  }
-  return used;
-}
-function setTableStyleSection(ctx, params) {
-  if (!pptxViewerCore.TABLE_STYLE_PART_SEQUENCE.includes(params.section)) {
-    throw new Error(
-      `Unknown table style section '${params.section}'. Valid sections: ${pptxViewerCore.TABLE_STYLE_PART_SEQUENCE.join(", ")}.`
-    );
-  }
-  const map = ctx.pptxData.tableStyleMap ?? {};
-  ctx.pptxData.tableStyleMap = map;
-  const normalizedId = pptxViewerCore.normalizeTableStyleGuid(params.styleId);
-  const entry = map[normalizedId];
-  if (!entry) {
-    throw new Error(
-      `Table style '${params.styleId}' is not loaded in this presentation. Use create_table_style to add a new one.`
-    );
-  }
-  if (params.styleName !== void 0) {
-    entry.styleName = params.styleName;
-  }
-  const mutableEntry = entry;
-  if (params.fill !== void 0) {
-    mutableEntry[`${params.section}Fill`] = params.fill;
-  }
-  if (params.text !== void 0) {
-    mutableEntry[`${params.section}Text`] = params.text;
-  }
-  if (params.borders !== void 0) {
-    mutableEntry[`${params.section}Borders`] = params.borders;
-  }
-  if (params.cell3D !== void 0) {
-    mutableEntry[`${params.section}Cell3D`] = params.cell3D;
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { styleId: normalizedId, section: params.section }
-  };
-}
-function createTableStyle(ctx, params) {
-  const map = ctx.pptxData.tableStyleMap ?? {};
-  ctx.pptxData.tableStyleMap = map;
-  const basedOn = params.basedOnStyleId ? map[pptxViewerCore.normalizeTableStyleGuid(params.basedOnStyleId)] : void 0;
-  if (params.basedOnStyleId && !basedOn) {
-    throw new Error(`basedOnStyleId '${params.basedOnStyleId}' is not a loaded table style.`);
-  }
-  const entry = pptxViewerCore.createTableStyleEntry(map, { styleName: params.styleName, basedOn });
-  pptxViewerCore.addTableStyleToMap(map, entry);
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { styleId: entry.styleId },
-    ...params.setAsDefault ? { saveOptions: { tableStylesDefaultId: entry.styleId } } : {}
-  };
-}
-function deleteTableStyle(ctx, params) {
-  const normalizedId = pptxViewerCore.normalizeTableStyleGuid(params.styleId);
-  if (!params.force) {
-    const used = tableStyleIdsInUse(ctx);
-    if (used.has(normalizedId)) {
-      throw new Error(
-        `Table style '${params.styleId}' is assigned to at least one table on this deck. Reassign those tables first, or pass force: true.`
-      );
-    }
-  }
-  const map = ctx.pptxData.tableStyleMap ?? {};
-  ctx.pptxData.tableStyleMap = map;
-  pptxViewerCore.deleteTableStyleFromMap(map, normalizedId);
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { deleted: true },
-    saveOptions: { tableStylesToDelete: [normalizedId] }
-  };
-}
-function assignTableStyle(ctx, params) {
-  const el = findTableElement(ctx, params.slideIndex, params.elementId);
-  if (!el.tableData) {
-    throw new Error(`Table '${params.elementId}' has no tableData.`);
-  }
-  const styleId = params.styleId ?? ctx.pptxData.tableStylesDefaultId;
-  if (!styleId) {
-    throw new Error(
-      "styleId was not provided and this presentation has no tableStylesDefaultId to fall back to."
-    );
-  }
-  const normalizedId = pptxViewerCore.normalizeTableStyleGuid(styleId);
-  el.tableData.tableStyleId = normalizedId;
-  if (params.bandedRows !== void 0) {
-    el.tableData.bandedRows = params.bandedRows;
-  }
-  if (params.bandedColumns !== void 0) {
-    el.tableData.bandedColumns = params.bandedColumns;
-  }
-  if (params.firstRowHeader !== void 0) {
-    el.tableData.firstRowHeader = params.firstRowHeader;
-  }
-  if (params.lastRow !== void 0) {
-    el.tableData.lastRow = params.lastRow;
-  }
-  if (params.firstCol !== void 0) {
-    el.tableData.firstCol = params.firstCol;
-  }
-  if (params.lastCol !== void 0) {
-    el.tableData.lastCol = params.lastCol;
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { elementId: params.elementId, styleId: normalizedId }
-  };
-}
-function updateTableCells(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  const el = slide.elements.find((e) => e.id === params.elementId);
-  if (!el) {
-    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
-  }
-  if (el.type !== "table") {
-    throw new Error(`Element '${params.elementId}' is not a table.`);
-  }
-  const tbl = el;
-  if (!tbl.tableData) {
-    throw new Error(`Table '${params.elementId}' has no tableData.`);
-  }
-  let count = 0;
-  for (const cellUpdate of params.cells) {
-    const row = tbl.tableData.rows[cellUpdate.row];
-    if (!row) {
-      throw new Error(
-        `Row ${cellUpdate.row} out of range (table has ${tbl.tableData.rows.length} rows).`
-      );
-    }
-    const cell = row.cells[cellUpdate.col];
-    if (!cell) {
-      throw new Error(`Column ${cellUpdate.col} out of range (row has ${row.cells.length} cells).`);
-    }
-    cell.text = cellUpdate.text;
-    count++;
-  }
-  return {
-    pptxData: ctx.pptxData,
-    dirty: true,
-    result: { updatedCount: count }
-  };
-}
-function manageTableStructure(ctx, params) {
-  const err = validateSlideIndex(params.slideIndex, ctx.pptxData.slides.length);
-  if (err) {
-    throw new Error(err);
-  }
-  const slide = ctx.pptxData.slides[params.slideIndex];
-  const el = slide.elements.find((e) => e.id === params.elementId);
-  if (!el) {
-    throw new Error(`Element '${params.elementId}' not found on slide ${params.slideIndex}.`);
-  }
-  if (el.type !== "table") {
-    throw new Error(`Element '${params.elementId}' is not a table.`);
-  }
-  const tbl = el;
-  if (!tbl.tableData) {
-    throw new Error(`Table '${params.elementId}' has no tableData.`);
-  }
-  const { rows, columnWidths } = tbl.tableData;
-  const source = { ...tbl, tableData: structuredClone(tbl.tableData) };
-  let edit;
-  const colCount = columnWidths.length;
-  const rowCount = rows.length;
-  switch (params.action) {
-    case "insertRow": {
-      const pos = params.position !== void 0 ? Math.min(Math.max(params.position, 0), rowCount) : rowCount;
-      const newRow = {
-        height: 40,
-        cells: Array.from({ length: colCount }, (_, c) => ({
-          text: params.cellTexts?.[c] ?? ""
-        }))
-      };
-      rows.splice(pos, 0, newRow);
-      edit = { axis: "row", action: "insert", index: pos };
-      break;
-    }
-    case "deleteRow": {
-      if (rowCount <= 1) {
-        throw new Error("Cannot delete the last row of a table.");
-      }
-      const ref = params.referenceIndex ?? rowCount - 1;
-      if (ref < 0 || ref >= rowCount) {
-        throw new Error(`Row index ${ref} out of range (0\u2013${rowCount - 1}).`);
-      }
-      rows.splice(ref, 1);
-      edit = { axis: "row", action: "delete", index: ref };
-      break;
-    }
-    case "insertColumn": {
-      const pos = params.position !== void 0 ? Math.min(Math.max(params.position, 0), colCount) : colCount;
-      const newWidth = 1 / (colCount + 1);
-      const scaleFactor = colCount / (colCount + 1);
-      for (let i = 0; i < columnWidths.length; i++) {
-        columnWidths[i] *= scaleFactor;
-      }
-      columnWidths.splice(pos, 0, newWidth);
-      edit = { axis: "column", action: "insert", index: pos };
-      for (let r = 0; r < rows.length; r++) {
-        rows[r].cells.splice(pos, 0, {
-          text: params.cellTexts?.[r] ?? ""
-        });
-      }
-      break;
-    }
-    case "deleteColumn": {
-      if (colCount <= 1) {
-        throw new Error("Cannot delete the last column of a table.");
-      }
-      const ref = params.referenceIndex ?? colCount - 1;
-      if (ref < 0 || ref >= colCount) {
-        throw new Error(`Column index ${ref} out of range (0\u2013${colCount - 1}).`);
-      }
-      const removedWidth = columnWidths[ref];
-      columnWidths.splice(ref, 1);
-      edit = { axis: "column", action: "delete", index: ref };
-      const remaining = columnWidths.length;
-      if (remaining > 0) {
-        const extra = removedWidth / remaining;
-        for (let i = 0; i < columnWidths.length; i++) {
-          columnWidths[i] += extra;
-        }
-      }
-      for (const row of rows) {
-        row.cells.splice(ref, 1);
-      }
-      break;
-    }
-    default: {
-      throw new Error(`Unknown action: ${String(params.action)}`);
-    }
-  }
-  const rawXml = pptxViewerCore.rebuildTableStructureInRawXml(source, tbl.tableData, edit);
-  if (rawXml) {
-    tbl.rawXml = rawXml;
-  }
-  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: {
-      repairCount: result.repairs.length,
-      repairs: result.repairs
-    },
-    repairedBytes: result.repaired
-  };
-}
-var PPTX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
-async function loadPresentation(filePath, execCtx) {
-  const rawBytes = await execCtx.filesystem.readFile(filePath);
-  if (execCtx.collaboration) {
-    const room = execCtx.collaboration.getRoom(filePath);
-    if (room) {
-      const codec = execCtx.collaboration.getCodec(filePath);
-      if (codec) {
-        const currentBytes = await codec.dehydrate(room.ydoc);
-        const handler2 = new pptxViewerCore.PptxHandler();
-        const pptxData2 = await handler2.load(currentBytes.buffer);
-        return { pptxData: pptxData2, rawBytes };
-      }
-    }
-  }
-  const handler = new pptxViewerCore.PptxHandler();
-  const pptxData = await handler.load(rawBytes.buffer);
-  return { pptxData, rawBytes };
-}
-async function savePresentation(filePath, pptxData, rawBytes, execCtx, tableStyleSaveOptions) {
-  const handler = new pptxViewerCore.PptxHandler();
-  await handler.load(rawBytes.buffer);
-  const outputBytes = await handler.save(pptxData.slides, {
-    headerFooter: pptxData.headerFooter,
-    // `pptxData.tableStyleMap` carries any in-memory table-style edits a
-    // tool made (e.g. `set_table_style_section`, `create_table_style`);
-    // without forwarding it here those edits were silently dropped on
-    // save even though the core save pipeline already supports them.
-    tableStyles: pptxData.tableStyleMap,
-    ...tableStyleSaveOptions
-  });
-  if (execCtx.collaboration) {
-    const room = execCtx.collaboration.getRoom(filePath);
-    if (room) {
-      const codec = execCtx.collaboration.getCodec(filePath);
-      if (codec) {
-        const origin = execCtx.collaboration.agentOrigin(execCtx.agentName ?? "pptx-tool");
-        await codec.hydrate(room.ydoc, outputBytes, origin);
-        if (execCtx.viewer) {
-          execCtx.viewer.replaceContent(filePath, outputBytes, {
-            markDirty: false,
-            mimeType: PPTX_MIME_TYPE
-          });
-        }
-        return { savedToDisk: false, routedThroughCollaboration: true };
-      }
-    }
-  }
-  await execCtx.filesystem.writeFile(filePath, outputBytes);
-  if (execCtx.viewer) {
-    execCtx.viewer.replaceContent(filePath, outputBytes, {
-      markDirty: false,
-      mimeType: PPTX_MIME_TYPE
-    });
-  }
-  return { savedToDisk: true, routedThroughCollaboration: false };
-}
-async function executeToolWithContext(filePath, execCtx, toolFn) {
-  const { pptxData, rawBytes } = await loadPresentation(filePath, execCtx);
-  const toolResult = await toolFn({ pptxData });
-  if (toolResult.dirty) {
-    const saveResult = await savePresentation(
-      filePath,
-      toolResult.pptxData,
-      rawBytes,
-      execCtx,
-      toolResult.saveOptions
-    );
-    return { ...toolResult.result, ...saveResult };
-  }
-  return toolResult.result;
-}
+var formatChartDataPoint = automation.apiToolsChartFormattingTools.formatChartDataPoint;
+var formatChartDataLabel = automation.apiToolsChartFormattingTools.formatChartDataLabel;
+var formatChartSeries = automation.apiToolsChartFormattingTools.formatChartSeries;
+var setChartHelperLineT = automation.apiToolsChartFormattingTools.setChartHelperLineT;
+var setChartColorMapOverrideT = automation.apiToolsChartFormattingTools.setChartColorMapOverrideT;
+var updateChart = automation.apiToolsChartTools.updateChart;
+var addChartSeriesT = automation.apiToolsChartTools.addChartSeriesT;
+var removeChartSeriesT = automation.apiToolsChartTools.removeChartSeriesT;
+var updateChartSeriesData = automation.apiToolsChartTools.updateChartSeriesData;
+var createChart = automation.apiToolsChartTools.createChart;
+var listChartUserShapesT = automation.apiToolsChartUserShapeTools.listChartUserShapesT;
+var addChartUserShapeT = automation.apiToolsChartUserShapeTools.addChartUserShapeT;
+var updateChartUserShapeT = automation.apiToolsChartUserShapeTools.updateChartUserShapeT;
+var removeChartUserShapeT = automation.apiToolsChartUserShapeTools.removeChartUserShapeT;
+var findText = automation.apiToolsContentTools.findText;
+var replaceText = automation.apiToolsContentTools.replaceText;
+var manageComments = automation.apiToolsContentTools.manageComments;
+var convertToMarkdown = automation.apiToolsConversionTools.convertToMarkdown;
+var addElement = automation.apiToolsElementTools.addElement;
+var updateElement = automation.apiToolsElementTools.updateElement;
+var renameElement = automation.apiToolsElementTools.renameElement;
+var deleteElements = automation.apiToolsElementTools.deleteElements;
+var arrangeElements = automation.apiToolsElementTools.arrangeElements;
+var cloneElement = automation.apiToolsElementTools.cloneElement;
+var setElementAnimation = automation.apiToolsElementTools.setElementAnimation;
+var groupElements = automation.apiToolsElementTools.groupElements;
+var ungroupElements = automation.apiToolsElementTools.ungroupElements;
+var batchUpdateElements = automation.apiToolsElementTools.batchUpdateElements;
+var exportToSvg = automation.apiToolsExportTools.exportToSvg;
+var exportSlideSvg = automation.apiToolsExportTools.exportSlideSvg;
+var replaceGeometry = automation.apiToolsGeometryTools.replaceGeometry;
+var manageHyperlinks = automation.apiToolsHyperlinkTools.manageHyperlinks;
+var exportToJson = automation.apiToolsJsonTools.exportToJson;
+var importFromJson = automation.apiToolsJsonTools.importFromJson;
+var getLayouts = automation.apiToolsLayoutTools.getLayouts;
+var applyLayout = automation.apiToolsLayoutTools.applyLayout;
+var setElementLockT = automation.apiToolsLockTools.setElementLockT;
+var getMetadata = automation.apiToolsMetadataTools.getMetadata;
+var updateMetadata = automation.apiToolsMetadataTools.updateMetadata;
+var getOleContent = automation.apiToolsOleTools.getOleContent;
+var setOleSheetCell = automation.apiToolsOleTools.setOleSheetCell;
+var setOleDocumentParagraph = automation.apiToolsOleTools.setOleDocumentParagraph;
+var setOleDeckSlideTitle = automation.apiToolsOleTools.setOleDeckSlideTitle;
+var setOleObjectNameT = automation.apiToolsOleTools.setOleObjectNameT;
+var replaceOleFileT = automation.apiToolsOleTools.replaceOleFileT;
+var getPresentationProperties = automation.apiToolsPresentationTools.getPresentationProperties;
+var updatePresentationProperties = automation.apiToolsPresentationTools.updatePresentationProperties;
+var manageSections = automation.apiToolsSectionTools.manageSections;
+var getSlide = automation.apiToolsSlideTools.getSlide;
+var addSlide = automation.apiToolsSlideTools.addSlide;
+var deleteSlides = automation.apiToolsSlideTools.deleteSlides;
+var reorderSlides = automation.apiToolsSlideTools.reorderSlides;
+var duplicateSlide = automation.apiToolsSlideTools.duplicateSlide;
+var updateSlideProperties = automation.apiToolsSlideTools.updateSlideProperties;
+var setSlideTransition = automation.apiToolsSlideTools.setSlideTransition;
+var setCanvasSize = automation.apiToolsSlideTools.setCanvasSize;
+var manageSmartArt = automation.apiToolsSmartartTools.manageSmartArt;
+automation.apiToolsStyleTools.ALT_TEXT_ELEMENT_TYPES;
+automation.apiToolsStyleTools.TITLE_ELEMENT_TYPES;
+automation.apiToolsStyleTools.applyElementAltText;
+automation.apiToolsStyleTools.applyElementTitle;
+var updateElementStyle = automation.apiToolsStyleTools.updateElementStyle;
+var runAccessibilityCheck = automation.apiToolsStyleTools.runAccessibilityCheck;
+var setTableStyleSection = automation.apiToolsTableStyleTools.setTableStyleSection;
+var createTableStyle = automation.apiToolsTableStyleTools.createTableStyle;
+var deleteTableStyle = automation.apiToolsTableStyleTools.deleteTableStyle;
+var assignTableStyle = automation.apiToolsTableStyleTools.assignTableStyle;
+var updateTableCells = automation.apiToolsTableTools.updateTableCells;
+var manageTableStructure = automation.apiToolsTableTools.manageTableStructure;
+var findPlaceholdersT = automation.apiToolsTemplateTools.findPlaceholdersT;
+var applyTemplateT = automation.apiToolsTemplateTools.applyTemplateT;
+var getThemeInfo = automation.apiToolsThemeTools.getThemeInfo;
+var applyThemePreset = automation.apiToolsThemeTools.applyThemePreset;
+var updateThemeColors = automation.apiToolsThemeTools.updateThemeColors;
+var updateThemeFonts = automation.apiToolsThemeTools.updateThemeFonts;
+var validatePresentation = automation.apiToolsValidationTools.validatePresentation;
+var repairPresentation = automation.apiToolsValidationTools.repairPresentation;
+automation.apiExecution.loadPresentation;
+automation.apiExecution.savePresentation;
+var executeToolWithContext = automation.apiExecution.executeToolWithContext;
 
 // src/mcp/handlers.ts
 var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([".pptx", ".ppt"]);
@@ -4139,19 +1062,26 @@ async function runMcpTool(filePath, fn, options) {
 }
 
 // src/mcp/server.ts
-function createServer() {
-  const server2 = new mcp_js.McpServer({
+function createServer(options) {
+  const server = new mcp_js.McpServer({
     name: "pptx-viewer-tools",
     version: "1.0.0"
   });
-  server2.registerTool(
+  registerTools(server, options);
+  return server;
+}
+function registerTools(server, options) {
+  const runMcpTool2 = (filePath, fn) => runMcpTool(filePath, fn, options);
+  const resolveScopedDir2 = (dir) => resolveScopedDir(dir, options?.rootDir);
+  const resolveScopedFilePath2 = (filePath) => resolveScopedFilePath(filePath, options?.rootDir);
+  server.registerTool(
     "get_slide",
     {
       description: "Inspect a single slide: returns layout, notes, elements",
       inputSchema: GetSlideSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => getSlide(ctx, { slideIndex: params.slideIndex })
       );
@@ -4165,14 +1095,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "add_slide",
     {
       description: "Add a new blank slide to the presentation",
       inputSchema: AddSlideSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(params.filePath, (ctx) => addSlide(ctx, params));
+      const result = await runMcpTool2(params.filePath, (ctx) => addSlide(ctx, params));
       return {
         content: [
           {
@@ -4183,14 +1113,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "delete_slides",
     {
       description: "Delete one or more slides by index",
       inputSchema: DeleteSlidesSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => deleteSlides(ctx, {
           slideIndexes: params.slideIndexes
@@ -4206,14 +1136,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "reorder_slides",
     {
       description: "Reorder slides by providing a new index array",
       inputSchema: ReorderSlidesSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => reorderSlides(ctx, { newOrder: params.newOrder })
       );
@@ -4227,14 +1157,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "duplicate_slide",
     {
       description: "Duplicate a slide with new element IDs",
       inputSchema: DuplicateSlideSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => duplicateSlide(ctx, params)
       );
@@ -4248,14 +1178,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "update_slide_properties",
     {
       description: "Update slide background, notes, or visibility",
       inputSchema: UpdateSlidePropertiesSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => updateSlideProperties(ctx, params)
       );
@@ -4269,14 +1199,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "set_slide_transition",
     {
       description: "Set or remove a slide transition effect",
       inputSchema: SetSlideTransitionSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => setSlideTransition(ctx, params)
       );
@@ -4290,14 +1220,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "set_canvas_size",
     {
       description: "Change the presentation canvas dimensions",
       inputSchema: SetCanvasSizeSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => setCanvasSize(ctx, params)
       );
@@ -4311,14 +1241,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "add_element",
     {
       description: "Add a text, shape, image, table, or connector element",
       inputSchema: AddElementSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => addElement(ctx, params)
       );
@@ -4332,14 +1262,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "update_element",
     {
       description: "Update element position, size, text, or style",
       inputSchema: UpdateElementSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => updateElement(ctx, params)
       );
@@ -4353,14 +1283,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "rename_element",
     {
       description: "Rename an element (the selection pane's display name; cNvPr/@name)",
       inputSchema: RenameElementSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => renameElement(ctx, params)
       );
@@ -4374,14 +1304,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "delete_elements",
     {
       description: "Delete one or more elements by ID",
       inputSchema: DeleteElementsSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => deleteElements(ctx, params)
       );
@@ -4395,14 +1325,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "arrange_elements",
     {
       description: "Align elements or change z-order (layer)",
       inputSchema: ArrangeElementsSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => arrangeElements(ctx, params)
       );
@@ -4416,14 +1346,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "clone_element",
     {
       description: "Clone an element within or across slides",
       inputSchema: CloneElementSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => cloneElement(ctx, params)
       );
@@ -4437,14 +1367,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "set_element_animation",
     {
       description: "Set entrance/exit animation on an element",
       inputSchema: SetElementAnimationSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => setElementAnimation(ctx, params)
       );
@@ -4458,14 +1388,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "group_elements",
     {
       description: "Group multiple elements into a group",
       inputSchema: GroupElementsSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => groupElements(ctx, params)
       );
@@ -4479,14 +1409,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "ungroup_elements",
     {
       description: "Ungroup a group element back to individual elements",
       inputSchema: UngroupElementsSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => ungroupElements(ctx, params)
       );
@@ -4500,14 +1430,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "batch_update_elements",
     {
       description: "Apply the same properties to multiple elements",
       inputSchema: BatchUpdateElementsSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => batchUpdateElements(ctx, params)
       );
@@ -4521,14 +1451,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "update_table_cells",
     {
       description: "Update text content of table cells",
       inputSchema: UpdateTableCellsSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => updateTableCells(ctx, params)
       );
@@ -4542,14 +1472,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "manage_table_structure",
     {
       description: "Insert or delete table rows and columns",
       inputSchema: ManageTableStructureSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => manageTableStructure(ctx, params)
       );
@@ -4563,14 +1493,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "set_table_style_section",
     {
       description: "Patch the fill, text, borders, or cell3D of one section (wholeTbl, banding, first/last row/col, or a corner cell) of an existing loaded table style",
       inputSchema: SetTableStyleSectionSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => setTableStyleSection(ctx, params)
       );
@@ -4579,14 +1509,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "create_table_style",
     {
       description: "Create a new table style (optionally cloned from an existing one) and optionally set it as the default",
       inputSchema: CreateTableStyleSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => createTableStyle(ctx, params)
       );
@@ -4595,14 +1525,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "delete_table_style",
     {
       description: "Remove a table style from the presentation",
       inputSchema: DeleteTableStyleSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => deleteTableStyle(ctx, params)
       );
@@ -4611,14 +1541,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "assign_table_style",
     {
       description: "Assign a table style (and row/column emphasis flags) to an existing table",
       inputSchema: AssignTableStyleSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => assignTableStyle(ctx, params)
       );
@@ -4627,14 +1557,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "update_element_style",
     {
       description: "Update fill, stroke, shadow, glow, or image effects",
       inputSchema: UpdateElementStyleSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => updateElementStyle(ctx, params)
       );
@@ -4648,14 +1578,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "run_accessibility_check",
     {
       description: "Audit the presentation for accessibility issues",
       inputSchema: AccessibilityCheckSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => runAccessibilityCheck(ctx)
       );
@@ -4669,14 +1599,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "find_text",
     {
       description: "Search for text across all slides",
       inputSchema: FindTextSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(params.filePath, (ctx) => findText(ctx, params));
+      const result = await runMcpTool2(params.filePath, (ctx) => findText(ctx, params));
       return {
         content: [
           {
@@ -4687,14 +1617,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "replace_text",
     {
       description: "Find and replace text across slides",
       inputSchema: ReplaceTextSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => replaceText(ctx, params)
       );
@@ -4708,14 +1638,14 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "manage_comments",
     {
       description: "List, add, delete, or resolve slide comments",
       inputSchema: ManageCommentsSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => manageComments(ctx, params)
       );
@@ -4729,16 +1659,16 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "convert_to_markdown",
     {
       description: "Convert the presentation to Markdown format",
       inputSchema: ConvertToMarkdownSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
-        (ctx) => convertToMarkdown(ctx, { ...params, scopeOutputDir: resolveScopedDir })
+        (ctx) => convertToMarkdown(ctx, { ...params, scopeOutputDir: resolveScopedDir2 })
       );
       return {
         content: [
@@ -4750,414 +1680,414 @@ function createServer() {
       };
     }
   );
-  server2.registerTool(
+  server.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));
+      const result = await runMcpTool2(params.filePath, (ctx) => getThemeInfo(ctx));
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "apply_theme_preset",
     {
       description: "Apply a built-in theme preset to the presentation",
       inputSchema: ApplyThemePresetSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => applyThemePreset(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.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(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => updateThemeColors(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "update_theme_fonts",
     {
       description: "Update theme heading (major) and body (minor) fonts",
       inputSchema: UpdateThemeFontsSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => updateThemeFonts(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "update_chart",
     {
       description: "Update chart type, title, legend, data labels, axis, or categories",
       inputSchema: UpdateChartSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => updateChart(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "add_chart_series",
     {
       description: "Add a data series to an existing chart",
       inputSchema: AddChartSeriesSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => addChartSeriesT(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "remove_chart_series",
     {
       description: "Remove a data series from a chart by index",
       inputSchema: RemoveChartSeriesSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => removeChartSeriesT(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "update_chart_series_data",
     {
       description: "Update data values for a chart series",
       inputSchema: UpdateChartSeriesDataSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => updateChartSeriesData(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "create_chart",
     {
       description: "Create a new chart element on a slide",
       inputSchema: CreateChartSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => createChart(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "format_chart_data_point",
     {
       description: "Set per-data-point chart formatting: fill/stroke colour, stroke width, dash style (c:dPt/c:spPr), explosion, and marker override",
       inputSchema: FormatChartDataPointSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => formatChartDataPoint(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "format_chart_data_label",
     {
       description: "Set a per-data-point data-label override (c:dLbl): show flags, position, custom text, and the label's own fill/line formatting (c:spPr) and font (c:txPr)",
       inputSchema: FormatChartDataLabelSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => formatChartDataLabel(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "format_chart_series",
     {
       description: "Set a chart series marker (c:marker), trendline (c:trendline, incl. line width/dash), or error bars (c:errBars, incl. line width/dash)",
       inputSchema: FormatChartSeriesSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => formatChartSeries(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "set_chart_helper_line",
     {
       description: "Set or remove a chart-level helper line on a line/stock/combo chart: c:dropLines or c:hiLowLines",
       inputSchema: SetChartHelperLineSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => setChartHelperLineT(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "set_chart_color_map_override",
     {
       description: "Set or remove a chart's theme colour-map override (c:clrMapOvr), remapping theme colour roles for this chart only",
       inputSchema: SetChartColorMapOverrideSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => setChartColorMapOverrideT(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "chart_user_shape_list",
     {
       description: "List a chart's drawing-overlay shapes (c:userShapes)",
       inputSchema: ListChartUserShapesSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => listChartUserShapesT(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "chart_user_shape_add",
     {
       description: "Add a drawing-overlay shape (text box or connector) to a chart's c:userShapes",
       inputSchema: AddChartUserShapeSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => addChartUserShapeT(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "chart_user_shape_update",
     {
       description: "Move, resize, or restyle one of a chart's drawing-overlay shapes by index",
       inputSchema: UpdateChartUserShapeSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => updateChartUserShapeT(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "chart_user_shape_remove",
     {
       description: "Remove one of a chart's drawing-overlay shapes by index",
       inputSchema: RemoveChartUserShapeSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => removeChartUserShapeT(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.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(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => manageSmartArt(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "find_placeholders",
     {
       description: "Discover all {{placeholder}} tokens in the presentation",
       inputSchema: FindPlaceholdersSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => findPlaceholdersT(ctx)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "apply_template",
     {
       description: "Replace {{placeholder}} tokens with provided values (mail merge)",
       inputSchema: ApplyTemplateSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => applyTemplateT(ctx, { data: params.data })
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.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));
+      const result = await runMcpTool2(params.filePath, (ctx) => getMetadata(ctx));
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "update_metadata",
     {
       description: "Update presentation metadata (title, author, company, custom properties)",
       inputSchema: UpdateMetadataSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => updateMetadata(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "manage_sections",
     {
       description: "List, add, remove, reorder sections or move slides between sections",
       inputSchema: ManageSectionsSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => manageSections(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "export_to_svg",
     {
       description: "Export all or specific slides to SVG strings",
       inputSchema: ExportToSvgSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => exportToSvg(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "export_slide_svg",
     {
       description: "Export a single slide to SVG",
       inputSchema: ExportSlideSvgSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => exportSlideSvg(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "export_to_json",
     {
       description: "Export the presentation to the portable pptx-viewer-json document format (self-contained, binary assets embedded as base64)",
       inputSchema: ExportToJsonSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => exportToJson(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "import_from_json",
     {
       description: "Replace the presentation content with a deck imported from a pptx-viewer-json document",
       inputSchema: ImportFromJsonSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => importFromJson(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "manage_hyperlinks",
     {
       description: "List, set, or remove hyperlinks/actions on elements",
       inputSchema: ManageHyperlinksSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => manageHyperlinks(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.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(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => replaceGeometry(ctx, {
           ...params,
@@ -5167,21 +2097,21 @@ function createServer() {
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.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(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => setElementLockT(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "validate_presentation",
     {
       description: "Validate PPTX structural integrity (content types, relationships, XML)",
@@ -5189,13 +2119,13 @@ function createServer() {
     },
     async (params) => {
       const { readFile: readFile2 } = await import('fs/promises');
-      const safePath = resolveScopedFilePath(params.filePath);
+      const safePath = resolveScopedFilePath2(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(
+  server.registerTool(
     "repair_presentation",
     {
       description: "Auto-repair common PPTX structural issues",
@@ -5203,7 +2133,7 @@ function createServer() {
     },
     async (params) => {
       const { readFile: readFile2, writeFile: writeFile2 } = await import('fs/promises');
-      const safePath = resolveScopedFilePath(params.filePath);
+      const safePath = resolveScopedFilePath2(params.filePath);
       const bytes = await readFile2(safePath);
       const { result, repairedBytes } = await repairPresentation(
         bytes.buffer
@@ -5214,147 +2144,144 @@ function createServer() {
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "get_presentation_properties",
     {
       description: "Get slideshow properties (show type, loop, advance mode, slide range)",
       inputSchema: GetPresentationPropertiesSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => getPresentationProperties(ctx)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "update_presentation_properties",
     {
       description: "Update slideshow properties (show type, loop, advance mode, pen color)",
       inputSchema: UpdatePresentationPropertiesSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => updatePresentationProperties(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.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));
+      const result = await runMcpTool2(params.filePath, (ctx) => getLayouts(ctx));
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "apply_layout",
     {
       description: "Apply a slide layout to a specific slide",
       inputSchema: ApplyLayoutSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => applyLayout(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "ole_get_content",
     {
       description: "Inspect an embedded OLE object's editable content: resolved kind, plus the sheet grid, paragraph list, or nested-deck slide summaries, whichever applies",
       inputSchema: GetOleContentSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => getOleContent(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "ole_set_sheet_cell",
     {
       description: "Edit one cell of an embedded Excel OLE object's first worksheet",
       inputSchema: SetOleSheetCellSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => setOleSheetCell(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "ole_set_document_paragraph",
     {
       description: "Replace one paragraph's text in an embedded Word (.docx or legacy .doc) OLE object",
       inputSchema: SetOleDocumentParagraphSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => setOleDocumentParagraph(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "ole_set_deck_slide_title",
     {
       description: "Edit one text-bearing shape on one slide of an embedded nested-deck (PowerPoint) OLE object, via a full load/save round-trip through the nested deck (call ole_get_content first to discover each slide's elementIds)",
       inputSchema: SetOleDeckSlideTitleSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => setOleDeckSlideTitle(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "ole_replace_file",
     {
       description: `Replace an embedded OLE object's payload wholesale with an arbitrary file; works for any OLE kind, including a generic "Package" object or an unsupported format`,
       inputSchema: ReplaceOleFileSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => replaceOleFileT(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server2.registerTool(
+  server.registerTool(
     "ole_set_object_name",
     {
       description: "Rename an OLE object's Object Name (p:oleObj/@name); regenerates the baked-in icon caption too when the object is displayed as an icon",
       inputSchema: SetOleObjectNameSchema.shape
     },
     async (params) => {
-      const result = await runMcpTool(
+      const result = await runMcpTool2(
         params.filePath,
         (ctx) => setOleObjectNameT(ctx, params)
       );
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  return server2;
 }
 
-// src/mcp/index.ts
-var server = createServer();
-var transport = new stdio_js.StdioServerTransport();
-void server.connect(transport);
+exports.createServer = createServer;
+exports.registerTools = registerTools;