pptx-viewer-mcp 2.1.7 → 2.3.0

package/dist/mcp/index.js

@@ -68,6 +68,32 @@ var ConvertToMarkdownSchema = zod.z.object({
 var AccessibilityCheckSchema = zod.z.object({
   filePath: zod.z.string().describe("Path to the PPTX file")
 });
+var ThemeColorRefSchema = zod.z.object({
+  scheme: zod.z.enum([
+    "dk1",
+    "lt1",
+    "dk2",
+    "lt2",
+    "accent1",
+    "accent2",
+    "accent3",
+    "accent4",
+    "accent5",
+    "accent6",
+    "hlink",
+    "folHlink",
+    "bg1",
+    "tx1",
+    "bg2",
+    "tx2",
+    "phClr"
+  ]),
+  lumMod: zod.z.number().optional().describe("Multiply HSL luminance (0..1)"),
+  lumOff: zod.z.number().optional().describe("Add to HSL luminance after lumMod (0..1)"),
+  tint: zod.z.number().optional().describe("Blend towards white (0..1)"),
+  shade: zod.z.number().optional().describe("Blend towards black (0..1)"),
+  alpha: zod.z.number().optional().describe("Opacity fraction, 1 = opaque")
+});
 var AddElementSchema = zod.z.object({
   filePath: zod.z.string().describe("Path to the PPTX file"),
   slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
@@ -112,6 +138,12 @@ var UpdateElementSchema = zod.z.object({
   fontSize: zod.z.number().optional(),
   fontFamily: zod.z.string().optional(),
   fontColor: zod.z.string().optional(),
+  /**
+   * A theme colour for the run text. Wins on save; resolves `fontColor`
+   * immediately when `fontColor` was not also given. Passing `fontColor`
+   * alone clears a previously-set text theme colour.
+   */
+  fontThemeColor: ThemeColorRefSchema.optional(),
   bold: zod.z.boolean().optional(),
   italic: zod.z.boolean().optional(),
   underline: zod.z.boolean().optional(),
@@ -184,6 +216,32 @@ var BatchUpdateElementsSchema = zod.z.object({
   opacity: zod.z.number().min(0).max(1).optional(),
   hidden: zod.z.boolean().optional()
 });
+var ThemeColorRefSchema2 = zod.z.object({
+  scheme: zod.z.enum([
+    "dk1",
+    "lt1",
+    "dk2",
+    "lt2",
+    "accent1",
+    "accent2",
+    "accent3",
+    "accent4",
+    "accent5",
+    "accent6",
+    "hlink",
+    "folHlink",
+    "bg1",
+    "tx1",
+    "bg2",
+    "tx2",
+    "phClr"
+  ]),
+  lumMod: zod.z.number().optional().describe("Multiply HSL luminance (0..1)"),
+  lumOff: zod.z.number().optional().describe("Add to HSL luminance after lumMod (0..1)"),
+  tint: zod.z.number().optional().describe("Blend towards white (0..1)"),
+  shade: zod.z.number().optional().describe("Blend towards black (0..1)"),
+  alpha: zod.z.number().optional().describe("Opacity fraction, 1 = opaque")
+});
 var UpdateTableCellsSchema = zod.z.object({
   filePath: zod.z.string().describe("Path to the PPTX file"),
   slideIndex: zod.z.number().int().min(0),
@@ -210,6 +268,14 @@ var UpdateElementStyleSchema = zod.z.object({
   slideIndex: zod.z.number().int().min(0),
   elementId: zod.z.string(),
   fillColor: zod.z.string().optional(),
+  /**
+   * A theme colour for the fill (e.g. `{ scheme: 'accent1', lumMod: 0.8 }`
+   * for "Accent 1, Lighter 80%"). When set, the shape saves as
+   * `<a:schemeClr>` and keeps following the theme after a later theme
+   * change, instead of freezing today's resolved hex. Setting `fillColor`
+   * without this clears any previously-set fill theme colour.
+   */
+  fillThemeColor: ThemeColorRefSchema2.optional(),
   fillMode: zod.z.string().optional(),
   fillGradientStops: zod.z.array(
     zod.z.object({
@@ -222,6 +288,8 @@ var UpdateElementStyleSchema = zod.z.object({
   fillGradientType: zod.z.string().optional(),
   fillOpacity: zod.z.number().optional(),
   strokeColor: zod.z.string().optional(),
+  /** A theme colour for the outline; see `fillThemeColor` above. */
+  strokeThemeColor: ThemeColorRefSchema2.optional(),
   strokeWidth: zod.z.number().optional(),
   strokeDash: zod.z.string().optional(),
   strokeOpacity: zod.z.number().optional(),
@@ -268,6 +336,116 @@ var ManageCommentsSchema = zod.z.object({
   resolved: zod.z.boolean().optional(),
   includeResolved: zod.z.boolean().optional()
 });
+var TABLE_STYLE_SECTIONS = [
+  "wholeTbl",
+  "band1H",
+  "band2H",
+  "band1V",
+  "band2V",
+  "lastCol",
+  "firstCol",
+  "lastRow",
+  "seCell",
+  "swCell",
+  "firstRow",
+  "neCell",
+  "nwCell"
+];
+var TableStyleSimpleColorSchema = zod.z.object({
+  schemeColor: zod.z.string().describe('Theme colour key (e.g. "accent1"), or "" for a non-scheme fill'),
+  tint: zod.z.number().optional().describe("0-100000"),
+  shade: zod.z.number().optional().describe("0-100000"),
+  color: zod.z.string().optional().describe('Explicit hex colour, e.g. "#FF8800"')
+});
+var TableStyleFillSchema = zod.z.object({
+  schemeColor: zod.z.string(),
+  tint: zod.z.number().optional(),
+  shade: zod.z.number().optional(),
+  color: zod.z.string().optional(),
+  noFill: zod.z.boolean().optional(),
+  gradient: zod.z.object({
+    type: zod.z.enum(["linear", "radial"]),
+    angle: zod.z.number().optional(),
+    stops: zod.z.array(zod.z.object({ position: zod.z.number(), fill: TableStyleSimpleColorSchema }))
+  }).optional(),
+  pattern: zod.z.object({
+    preset: zod.z.string(),
+    foreground: TableStyleSimpleColorSchema.optional(),
+    background: TableStyleSimpleColorSchema.optional()
+  }).optional(),
+  image: zod.z.object({ path: zod.z.string().optional(), data: zod.z.string().optional() }).optional()
+});
+var TableStyleTextSchema = zod.z.object({
+  bold: zod.z.boolean().optional(),
+  italic: zod.z.boolean().optional(),
+  underline: zod.z.boolean().optional(),
+  fontSchemeColor: zod.z.string().optional(),
+  fontTint: zod.z.number().optional(),
+  fontShade: zod.z.number().optional(),
+  fontColor: zod.z.string().optional(),
+  fontFace: zod.z.string().optional(),
+  fontRefIdx: zod.z.string().optional()
+});
+var TableStyleBorderSideSchema = zod.z.object({
+  width: zod.z.number().optional(),
+  dash: zod.z.string().optional(),
+  fill: TableStyleSimpleColorSchema.optional(),
+  color: zod.z.string().optional(),
+  noFill: zod.z.boolean().optional()
+});
+var TableStyleBordersSchema = zod.z.object({
+  left: TableStyleBorderSideSchema.optional(),
+  right: TableStyleBorderSideSchema.optional(),
+  top: TableStyleBorderSideSchema.optional(),
+  bottom: TableStyleBorderSideSchema.optional(),
+  insideH: TableStyleBorderSideSchema.optional(),
+  insideV: TableStyleBorderSideSchema.optional(),
+  tl2br: TableStyleBorderSideSchema.optional(),
+  tr2bl: TableStyleBorderSideSchema.optional()
+});
+var TableStyleCell3DSchema = zod.z.object({
+  bevelWidth: zod.z.number().optional(),
+  bevelHeight: zod.z.number().optional(),
+  bevelPreset: zod.z.string().optional(),
+  material: zod.z.string().optional(),
+  lightRig: zod.z.string().optional(),
+  lightRigDirection: zod.z.string().optional()
+});
+var SetTableStyleSectionSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  styleId: zod.z.string().describe('Table style GUID, e.g. "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}"'),
+  section: zod.z.enum(TABLE_STYLE_SECTIONS).describe("Which of the 13 CT_TableStyle parts to patch"),
+  styleName: zod.z.string().optional().describe("Rename the style"),
+  fill: TableStyleFillSchema.optional(),
+  text: TableStyleTextSchema.optional(),
+  borders: TableStyleBordersSchema.optional(),
+  cell3D: TableStyleCell3DSchema.optional()
+});
+var CreateTableStyleSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  styleName: zod.z.string().describe("Display name for the new style"),
+  basedOnStyleId: zod.z.string().optional().describe("Deep-clone every section from this existing style GUID as the starting point"),
+  setAsDefault: zod.z.boolean().optional().describe("Repoint ppt/tableStyles.xml's default style at the new one")
+});
+var DeleteTableStyleSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  styleId: zod.z.string().describe("Table style GUID to remove"),
+  force: zod.z.boolean().optional().describe("Delete even though a table on this deck still references the style")
+});
+var AssignTableStyleSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0),
+  elementId: zod.z.string().describe("Table element ID"),
+  styleId: zod.z.string().optional().describe(
+    "Table style GUID to assign. Defaults to the presentation's current default table style when omitted."
+  ),
+  bandedRows: zod.z.boolean().optional(),
+  bandedColumns: zod.z.boolean().optional(),
+  firstRowHeader: zod.z.boolean().optional(),
+  lastRow: zod.z.boolean().optional(),
+  firstCol: zod.z.boolean().optional(),
+  lastCol: zod.z.boolean().optional()
+});
 var GetThemeInfoSchema = zod.z.object({
   filePath: zod.z.string().describe("Path to the PPTX file")
 });
@@ -297,6 +475,139 @@ var UpdateThemeFontsSchema = zod.z.object({
   majorFont: zod.z.string().optional().describe("Heading (major) font family"),
   minorFont: zod.z.string().optional().describe("Body (minor) font family")
 });
+var MarkerSymbolSchema = zod.z.enum([
+  "circle",
+  "dash",
+  "diamond",
+  "dot",
+  "none",
+  "picture",
+  "plus",
+  "square",
+  "star",
+  "triangle",
+  "x",
+  "auto"
+]);
+var DataLabelPositionSchema = zod.z.enum([
+  "bestFit",
+  "b",
+  "ctr",
+  "inBase",
+  "inEnd",
+  "l",
+  "outEnd",
+  "r",
+  "t"
+]);
+var FormatChartDataPointSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  elementId: zod.z.string().describe("Chart element ID"),
+  seriesIndex: zod.z.number().int().min(0).describe("Zero-based series index"),
+  pointIndex: zod.z.number().int().min(0).describe("Zero-based data point (category) index"),
+  fillColor: zod.z.string().optional().describe("Fill colour (hex) for this point only"),
+  strokeColor: zod.z.string().optional().describe("Outline colour (hex) for this point only"),
+  strokeWidth: zod.z.number().optional().describe("Outline width in points"),
+  strokeDashStyle: zod.z.string().optional().describe("Outline dash style, e.g. solid, dash, dashDot, sysDot"),
+  clearStyle: zod.z.boolean().optional().describe("Remove all per-point shape formatting"),
+  explosion: zod.z.number().nullable().optional().describe("Pie/doughnut slice pull-out distance 0-100; null clears it"),
+  marker: zod.z.object({
+    symbol: MarkerSymbolSchema.optional(),
+    size: zod.z.number().optional(),
+    fillColor: zod.z.string().optional()
+  }).nullable().optional().describe("Per-point marker override (line/scatter/bubble); null clears it")
+});
+var FormatChartDataLabelSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  elementId: zod.z.string().describe("Chart element ID"),
+  seriesIndex: zod.z.number().int().min(0).describe("Zero-based series index"),
+  pointIndex: zod.z.number().int().min(0).describe("Zero-based data point (category) index"),
+  remove: zod.z.boolean().optional().describe("Remove the per-point label override entirely"),
+  showValue: zod.z.boolean().optional(),
+  showCategory: zod.z.boolean().optional(),
+  showSeriesName: zod.z.boolean().optional(),
+  showPercent: zod.z.boolean().optional(),
+  showLegendKey: zod.z.boolean().optional(),
+  position: DataLabelPositionSchema.optional(),
+  text: zod.z.string().optional().describe("Custom label text override; '' clears it"),
+  spPr: zod.z.object({
+    fillColor: zod.z.string().optional(),
+    strokeColor: zod.z.string().optional(),
+    strokeWidth: zod.z.number().optional(),
+    strokeDashStyle: zod.z.string().optional()
+  }).nullable().optional().describe("This label's own fill/line formatting; null removes it"),
+  txPr: zod.z.object({
+    fontFamily: zod.z.string().optional(),
+    fontSize: zod.z.number().optional(),
+    bold: zod.z.boolean().optional(),
+    italic: zod.z.boolean().optional(),
+    color: zod.z.string().optional()
+  }).nullable().optional().describe("This label's own font; null removes it")
+});
+var FormatChartSeriesSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  elementId: zod.z.string().describe("Chart element ID"),
+  seriesIndex: zod.z.number().int().min(0).describe("Zero-based series index"),
+  marker: zod.z.object({
+    symbol: MarkerSymbolSchema.optional(),
+    size: zod.z.number().optional(),
+    fillColor: zod.z.string().optional(),
+    strokeColor: zod.z.string().optional(),
+    strokeWidth: zod.z.number().optional(),
+    strokeDashStyle: zod.z.string().optional()
+  }).nullable().optional().describe("Series marker (line/scatter/bubble/radar); null removes it"),
+  trendline: zod.z.object({
+    trendlineType: zod.z.enum([
+      "linear",
+      "exponential",
+      "logarithmic",
+      "polynomial",
+      "power",
+      "movingAvg"
+    ]),
+    color: zod.z.string().optional(),
+    lineWidth: zod.z.number().optional().describe("Trendline width in points"),
+    lineDashStyle: zod.z.string().optional(),
+    order: zod.z.number().optional().describe("Polynomial order, 2-6"),
+    period: zod.z.number().optional().describe("Moving-average period"),
+    displayEq: zod.z.boolean().optional(),
+    displayRSq: zod.z.boolean().optional()
+  }).nullable().optional().describe("Series trendline; null removes it"),
+  errorBars: zod.z.object({
+    direction: zod.z.enum(["x", "y"]),
+    barType: zod.z.enum(["both", "minus", "plus"]),
+    valType: zod.z.enum(["cust", "fixedVal", "percentage", "stdDev", "stdErr"]),
+    val: zod.z.number().optional(),
+    customPlus: zod.z.array(zod.z.number()).optional(),
+    customMinus: zod.z.array(zod.z.number()).optional(),
+    noEndCap: zod.z.boolean().optional(),
+    color: zod.z.string().optional(),
+    width: zod.z.number().optional().describe("Error-bar line width in points"),
+    dashStyle: zod.z.string().optional()
+  }).nullable().optional().describe("Series error bars; null removes them")
+});
+var SetChartHelperLineSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  elementId: zod.z.string().describe("Chart element ID"),
+  line: zod.z.enum(["dropLines", "hiLowLines"]).describe("Which helper line to set"),
+  style: zod.z.object({
+    color: zod.z.string().optional(),
+    width: zod.z.number().optional(),
+    dashStyle: zod.z.string().optional()
+  }).nullable().describe("Line colour/width/dash; {} shows the line with defaults, null removes it")
+});
+var SetChartColorMapOverrideSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  elementId: zod.z.string().describe("Chart element ID"),
+  overrides: zod.z.record(zod.z.string(), zod.z.string()).nullable().describe(
+    'Theme colour role remap (bg1/tx1/bg2/tx2/accent1-6/hlink/folHlink -> role), e.g. { "accent1": "accent2" }; null removes the override'
+  )
+});
 var UpdateChartSchema = zod.z.object({
   filePath: zod.z.string().describe("Path to the PPTX file"),
   slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
@@ -376,6 +687,50 @@ var CreateChartSchema = zod.z.object({
     position: zod.z.string().optional()
   }).optional().describe("Legend configuration")
 });
+var PointSchema = zod.z.object({ x: zod.z.number(), y: zod.z.number() });
+var ExtentSchema = zod.z.object({ cx: zod.z.number(), cy: zod.z.number() });
+var ChartUserShapeInputSchema = zod.z.object({
+  kind: zod.z.enum(["sp", "cxnSp"]).optional().describe('Overlay shape kind: "sp" (text/preset shape, default) or "cxnSp" (connector).'),
+  anchor: zod.z.enum(["rel", "abs"]).optional().describe(
+    'Anchor kind: "rel" (default, resizes with the chart; needs `to`) or "abs" (fixed EMU size; needs `ext`).'
+  ),
+  from: PointSchema.describe("Top-left corner as chart-relative fractions (0-1 each)."),
+  to: PointSchema.optional().describe(
+    "Bottom-right corner as chart-relative fractions; rel anchors only."
+  ),
+  ext: ExtentSchema.optional().describe("Width/height in EMU; abs anchors only."),
+  prst: zod.z.string().optional().describe('Preset geometry name (e.g. "rect", "roundRect"); default "rect".'),
+  fill: zod.z.string().optional().describe('Solid fill colour, hex (e.g. "#FFFF00").'),
+  stroke: zod.z.string().optional().describe("Line colour, hex."),
+  strokeWidth: zod.z.number().optional().describe("Line width in points."),
+  text: zod.z.string().optional().describe("Plain text content, centred in the shape.")
+});
+var ListChartUserShapesSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  elementId: zod.z.string().describe("Chart element ID")
+});
+var AddChartUserShapeSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  elementId: zod.z.string().describe("Chart element ID"),
+  shape: ChartUserShapeInputSchema.describe("The overlay shape to add.")
+});
+var UpdateChartUserShapeSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  elementId: zod.z.string().describe("Chart element ID"),
+  index: zod.z.number().int().min(0).describe("Zero-based overlay-shape index (from chart_user_shape_list)"),
+  patch: ChartUserShapeInputSchema.partial().describe(
+    "Fields to overwrite; anything omitted is left as-is."
+  )
+});
+var RemoveChartUserShapeSchema = zod.z.object({
+  filePath: zod.z.string().describe("Path to the PPTX file"),
+  slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
+  elementId: zod.z.string().describe("Chart element ID"),
+  index: zod.z.number().int().min(0).describe("Zero-based overlay-shape index to remove")
+});
 var ManageSmartArtSchema = zod.z.object({
   filePath: zod.z.string().describe("Path to the PPTX file"),
   slideIndex: zod.z.number().int().min(0).describe("Zero-based slide index"),
@@ -515,39 +870,6 @@ var ApplyLayoutSchema = zod.z.object({
   layoutName: zod.z.string().optional().describe("Layout name to apply"),
   layoutType: zod.z.string().optional().describe("Layout type to apply (alternative to name)")
 });
-
-// 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" }
-    });
-  }
-}
 function generateElementId() {
   return `el-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -655,6 +977,133 @@ function validateSlideIndex(slideIndex, slideCount) {
   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);
@@ -795,6 +1244,67 @@ function createChart(ctx, params) {
     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 } };
+}
 var MAX_REGEX_LEN = 200;
 function hasNestedUnboundedQuantifier(pattern) {
   return /\([^)]*[+*]\)[+*]/u.test(pattern);
@@ -1319,8 +1829,17 @@ function updateElement(ctx, params) {
     if (params.fontFamily !== void 0) {
       textEl.textStyle.fontFamily = params.fontFamily;
     }
-    if (params.fontColor !== void 0) {
+    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;
@@ -2560,8 +3079,17 @@ function updateElementStyle(ctx, params) {
       el.shapeStyle = {};
     }
     const ss = el.shapeStyle;
-    if (params.fillColor !== void 0) {
+    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;
@@ -2578,8 +3106,17 @@ function updateElementStyle(ctx, params) {
     if (params.fillOpacity !== void 0) {
       ss.fillOpacity = params.fillOpacity;
     }
-    if (params.strokeColor !== void 0) {
+    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;
@@ -2729,6 +3266,142 @@ function runAccessibilityCheck(ctx) {
     }
   };
 }
+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 }
+  };
+}
 
 // src/tools/table-tools.ts
 function updateTableCells(ctx, params) {
@@ -3008,11 +3681,17 @@ async function loadPresentation(filePath, execCtx) {
   const pptxData = await handler.load(rawBytes.buffer);
   return { pptxData, rawBytes };
 }
-async function savePresentation(filePath, pptxData, rawBytes, execCtx) {
+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
+    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);
@@ -3044,7 +3723,13 @@ 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);
+    const saveResult = await savePresentation(
+      filePath,
+      toolResult.pptxData,
+      rawBytes,
+      execCtx,
+      toolResult.saveOptions
+    );
     return { ...toolResult.result, ...saveResult };
   }
   return toolResult.result;
@@ -3524,6 +4209,70 @@ function createServer() {
       };
     }
   );
+  server2.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(
+        params.filePath,
+        (ctx) => setTableStyleSection(ctx, params)
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.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(
+        params.filePath,
+        (ctx) => createTableStyle(ctx, params)
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.registerTool(
+    "delete_table_style",
+    {
+      description: "Remove a table style from the presentation",
+      inputSchema: DeleteTableStyleSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => deleteTableStyle(ctx, params)
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.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(
+        params.filePath,
+        (ctx) => assignTableStyle(ctx, params)
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
   server2.registerTool(
     "update_element_style",
     {
@@ -3770,6 +4519,132 @@ function createServer() {
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
+  server2.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(
+        params.filePath,
+        (ctx) => formatChartDataPoint(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.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(
+        params.filePath,
+        (ctx) => formatChartDataLabel(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.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(
+        params.filePath,
+        (ctx) => formatChartSeries(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.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(
+        params.filePath,
+        (ctx) => setChartHelperLineT(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.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(
+        params.filePath,
+        (ctx) => setChartColorMapOverrideT(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.registerTool(
+    "chart_user_shape_list",
+    {
+      description: "List a chart's drawing-overlay shapes (c:userShapes)",
+      inputSchema: ListChartUserShapesSchema.shape
+    },
+    async (params) => {
+      const result = await runMcpTool(
+        params.filePath,
+        (ctx) => listChartUserShapesT(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.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(
+        params.filePath,
+        (ctx) => addChartUserShapeT(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.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(
+        params.filePath,
+        (ctx) => updateChartUserShapeT(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server2.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(
+        params.filePath,
+        (ctx) => removeChartUserShapeT(ctx, params)
+      );
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
   server2.registerTool(
     "manage_smart_art",
     {