pptx-react-viewer 1.1.3 → 1.1.4

package/node_modules/pptx-viewer-core/dist/cli/index.js

@@ -4426,12 +4426,25 @@ function svgToCustomGeometryPaths(pathData, width, height) {
 function pointToXml(pt) {
   return { "@_x": String(Math.round(pt.x)), "@_y": String(Math.round(pt.y)) };
 }
-function customGeometryPathsToXml(paths) {
+function customGeometryPathsToXml(paths, rawData) {
   const xmlPaths = paths.map((path2) => {
     const pathXml = {
       "@_w": String(Math.round(path2.width)),
       "@_h": String(Math.round(path2.height))
     };
+    if (path2.fillMode) {
+      pathXml["@_fill"] = path2.fillMode;
+    }
+    if (path2.stroke === false) {
+      pathXml["@_stroke"] = "0";
+    } else if (path2.stroke === true) {
+      pathXml["@_stroke"] = "1";
+    }
+    if (path2.extrusionOk === true) {
+      pathXml["@_extrusionOk"] = "1";
+    } else if (path2.extrusionOk === false) {
+      pathXml["@_extrusionOk"] = "0";
+    }
     const moveToList = [];
     const lnToList = [];
     const cubicBezToList = [];
@@ -4489,12 +4502,12 @@ function customGeometryPathsToXml(paths) {
     }
     return pathXml;
   });
-  return {
+  const result = {
     "a:avLst": {},
-    "a:gdLst": {},
-    "a:ahLst": {},
-    "a:cxnLst": {},
-    "a:rect": {
+    "a:gdLst": rawData?.gdLstXml ?? {},
+    "a:ahLst": rawData?.ahLstXml ?? {},
+    "a:cxnLst": rawData?.cxnLstXml ?? {},
+    "a:rect": rawData?.rectXml ?? {
       "@_l": "l",
       "@_t": "t",
       "@_r": "r",
@@ -4504,6 +4517,7 @@ function customGeometryPathsToXml(paths) {
       "a:path": xmlPaths.length === 1 ? xmlPaths[0] : xmlPaths
     }
   };
+  return result;
 }
 
 // src/core/builders/sdk/ElementFactory.ts
@@ -5250,6 +5264,9 @@ ${Array.from(
 <p:presentation xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
   xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
   xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
+  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+  xmlns:p14="http://schemas.microsoft.com/office/powerpoint/2010/main"
+  xmlns:p15="http://schemas.microsoft.com/office/powerpoint/2012/main"
   saveSubsetFonts="1">
   <p:sldMasterIdLst>
     <p:sldMasterId id="2147483648" r:id="rId1"/>
@@ -6671,6 +6688,22 @@ var PptxPresentationSlidesReconciler = class {
 };
 
 // src/core/core/builders/PptxSlideRelationshipRegistry.ts
+function isExternalTarget(target) {
+  const normalized = target.trim();
+  if (normalized.length === 0) {
+    return false;
+  }
+  const colonIdx = normalized.indexOf(":");
+  if (colonIdx <= 0) {
+    return false;
+  }
+  const slashIdx = normalized.indexOf("/");
+  if (slashIdx !== -1 && slashIdx < colonIdx) {
+    return false;
+  }
+  const scheme = normalized.slice(0, colonIdx);
+  return /^[A-Za-z][A-Za-z0-9+\-.]*$/.test(scheme);
+}
 var PptxSlideRelationshipRegistry = class {
   relationships;
   usedRelationshipIds = /* @__PURE__ */ new Set();
@@ -6741,7 +6774,7 @@ var PptxSlideRelationshipRegistry = class {
       return existingRelationshipId;
     }
     const relationshipId = this.nextRelationshipId();
-    const targetMode = /^(https?:|mailto:|ftp:|file:)/i.test(normalizedTarget) ? "External" : void 0;
+    const targetMode = isExternalTarget(normalizedTarget) ? "External" : void 0;
     this.upsertRelationship(
       relationshipId,
       this.hyperlinkRelationshipType,
@@ -6991,6 +7024,82 @@ var PptxSlideNotesPartUpdater = class {
   }
 };
 
+// src/core/utils/xml-reorder.ts
+function reorderObjectKeys(obj, schemaOrder) {
+  const result = {};
+  const consumed = /* @__PURE__ */ new Set();
+  for (const key of schemaOrder) {
+    if (Object.hasOwn(obj, key)) {
+      const value = obj[key];
+      if (value !== void 0) {
+        result[key] = value;
+      }
+      consumed.add(key);
+    }
+  }
+  for (const key of Object.keys(obj)) {
+    if (consumed.has(key)) {
+      continue;
+    }
+    const value = obj[key];
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var EFFECT_LST_ORDER = [
+  "a:blur",
+  "a:fillOverlay",
+  "a:glow",
+  "a:innerShdw",
+  "a:outerShdw",
+  "a:prstShdw",
+  "a:reflection",
+  "a:softEdge"
+];
+var SP_PR_ORDER = [
+  "a:xfrm",
+  "a:custGeom",
+  "a:prstGeom",
+  "a:noFill",
+  "a:solidFill",
+  "a:gradFill",
+  "a:blipFill",
+  "a:pattFill",
+  "a:grpFill",
+  "a:ln",
+  "a:effectLst",
+  "a:effectDag",
+  "a:scene3d",
+  "a:sp3d",
+  "a:extLst"
+];
+var TC_PR_BORDERS_ORDER = [
+  "a:lnL",
+  "a:lnR",
+  "a:lnT",
+  "a:lnB",
+  "a:lnTlToBr",
+  "a:lnBlToTr",
+  "a:cell3D",
+  "a:noFill",
+  "a:solidFill",
+  "a:gradFill",
+  "a:blipFill",
+  "a:pattFill",
+  "a:grpFill",
+  "a:headers",
+  "a:extLst"
+];
+var BLIP_FILL_ORDER = ["a:blip", "a:srcRect", "a:tile", "a:stretch"];
+var SHAPE_STYLE_ORDER = [
+  "a:lnRef",
+  "a:fillRef",
+  "a:effectRef",
+  "a:fontRef"
+];
+
 // src/core/core/builders/PptxSlideBackgroundBuilder.ts
 var PptxSlideBackgroundBuilder = class {
   applyBackground(init) {
@@ -7026,10 +7135,13 @@ var PptxSlideBackgroundBuilder = class {
           init.slideImageRelationshipType,
           relativeBackgroundImagePath
         );
-        backgroundProperties["a:blipFill"] = {
-          "a:blip": { "@_r:embed": backgroundRelationshipId },
-          "a:stretch": { "a:fillRect": {} }
-        };
+        backgroundProperties["a:blipFill"] = reorderObjectKeys(
+          {
+            "a:blip": { "@_r:embed": backgroundRelationshipId },
+            "a:stretch": { "a:fillRect": {} }
+          },
+          BLIP_FILL_ORDER
+        );
       }
     } else if (hasBackgroundColor && init.slide.backgroundColor) {
       backgroundProperties["a:solidFill"] = {
@@ -7773,6 +7885,45 @@ var PptxGradientStyleCodec = class {
       b: Number.isFinite(b) ? this.context.clampUnitInterval(b / 1e5) : 0
     };
   }
+  extractGradientFlip(gradFill) {
+    const flipRaw = String(gradFill["@_flip"] || "").trim().toLowerCase();
+    if (flipRaw === "x" || flipRaw === "y" || flipRaw === "xy" || flipRaw === "none") {
+      return flipRaw;
+    }
+    return void 0;
+  }
+  extractGradientRotWithShape(gradFill) {
+    const rot = gradFill["@_rotWithShape"];
+    if (rot === void 0 || rot === null) {
+      return void 0;
+    }
+    const token = String(rot).trim().toLowerCase();
+    if (token === "1" || token === "true") {
+      return true;
+    }
+    if (token === "0" || token === "false") {
+      return false;
+    }
+    return void 0;
+  }
+  extractGradientScaled(gradFill) {
+    const lin = gradFill["a:lin"];
+    if (!lin) {
+      return void 0;
+    }
+    const scaled = lin["@_scaled"];
+    if (scaled === void 0 || scaled === null) {
+      return void 0;
+    }
+    const token = String(scaled).trim().toLowerCase();
+    if (token === "1" || token === "true") {
+      return true;
+    }
+    if (token === "0" || token === "false") {
+      return false;
+    }
+    return void 0;
+  }
   extractGradientAngle(gradFill) {
     const angleRaw = Number.parseInt(
       String(gradFill["a:lin"]?.["@_ang"] || ""),
@@ -7859,11 +8010,14 @@ var PptxGradientStyleCodec = class {
       return void 0;
     }
     const gradientType = shapeStyle.fillGradientType || "linear";
-    const gradientXml = {
-      "a:gsLst": {
-        "a:gs": stops
-      }
-    };
+    const gradientXml = {};
+    if (shapeStyle.fillGradientFlip && shapeStyle.fillGradientFlip !== "none") {
+      gradientXml["@_flip"] = shapeStyle.fillGradientFlip;
+    }
+    if (shapeStyle.fillGradientRotWithShape !== void 0) {
+      gradientXml["@_rotWithShape"] = shapeStyle.fillGradientRotWithShape ? "1" : "0";
+    }
+    gradientXml["a:gsLst"] = { "a:gs": stops };
     if (gradientType === "radial") {
       const pathType = shapeStyle.fillGradientPathType || "circle";
       const pathXml = {
@@ -7893,10 +8047,15 @@ var PptxGradientStyleCodec = class {
       gradientXml["a:path"] = pathXml;
     } else {
       const normalizedAngle = typeof shapeStyle.fillGradientAngle === "number" && Number.isFinite(shapeStyle.fillGradientAngle) ? shapeStyle.fillGradientAngle : 90;
-      gradientXml["a:lin"] = {
-        "@_ang": String(Math.round(normalizedAngle * 6e4)),
-        "@_scaled": "1"
+      const linNode = {
+        "@_ang": String(Math.round(normalizedAngle * 6e4))
       };
+      if (shapeStyle.fillGradientScaled !== void 0) {
+        linNode["@_scaled"] = shapeStyle.fillGradientScaled ? "1" : "0";
+      } else {
+        linNode["@_scaled"] = "1";
+      }
+      gradientXml["a:lin"] = linNode;
     }
     return gradientXml;
   }
@@ -8293,6 +8452,30 @@ var PRESET_SHADOW_OPACITY_MAP = {
 };
 
 // src/core/core/builders/PptxShapeEffectStyleExtractor.ts
+var VALID_ALIGNMENTS = /* @__PURE__ */ new Set(["tl", "t", "tr", "l", "ctr", "r", "bl", "b", "br"]);
+function parseIntAttr(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseAlignmentAttr(value) {
+  const v = String(value ?? "").trim();
+  return VALID_ALIGNMENTS.has(v) ? v : void 0;
+}
+function parseBoolAttr(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (value === "1" || value === "true") {
+    return true;
+  }
+  if (value === "0" || value === "false") {
+    return false;
+  }
+  return void 0;
+}
 var PptxShapeEffectStyleExtractor = class {
   context;
   constructor(context) {
@@ -8316,7 +8499,12 @@ var PptxShapeEffectStyleExtractor = class {
     const shadowOffsetX = distance !== void 0 ? Math.round(Math.cos(directionRadians) * distance * 100) / 100 : void 0;
     const shadowOffsetY = distance !== void 0 ? Math.round(Math.sin(directionRadians) * distance * 100) / 100 : void 0;
     const rotateWithShape = outerShadow["@_rotWithShape"];
-    const shadowRotateWithShape = typeof rotateWithShape === "boolean" ? rotateWithShape : rotateWithShape === "1" || rotateWithShape === "true" ? true : void 0;
+    const shadowRotateWithShape = typeof rotateWithShape === "boolean" ? rotateWithShape : rotateWithShape === "1" || rotateWithShape === "true" ? true : rotateWithShape === "0" || rotateWithShape === "false" ? false : void 0;
+    const shadowScaleX = parseIntAttr(outerShadow["@_sx"]);
+    const shadowScaleY = parseIntAttr(outerShadow["@_sy"]);
+    const shadowSkewX = parseIntAttr(outerShadow["@_kx"]);
+    const shadowSkewY = parseIntAttr(outerShadow["@_ky"]);
+    const shadowAlignment = parseAlignmentAttr(outerShadow["@_algn"]);
     return {
       shadowColor,
       shadowOpacity,
@@ -8325,7 +8513,12 @@ var PptxShapeEffectStyleExtractor = class {
       shadowOffsetY,
       shadowAngle: directionDegrees,
       shadowDistance: distance,
-      shadowRotateWithShape
+      shadowRotateWithShape,
+      shadowScaleX,
+      shadowScaleY,
+      shadowSkewX,
+      shadowSkewY,
+      shadowAlignment
     };
   }
   extractPresetShadowStyle(effectLstParent) {
@@ -8371,12 +8564,14 @@ var PptxShapeEffectStyleExtractor = class {
     const directionRadians = directionDegrees * Math.PI / 180;
     const innerShadowOffsetX = distance !== void 0 ? Math.round(Math.cos(directionRadians) * distance * 100) / 100 : void 0;
     const innerShadowOffsetY = distance !== void 0 ? Math.round(Math.sin(directionRadians) * distance * 100) / 100 : void 0;
+    const innerShadowRotateWithShape = parseBoolAttr(innerShadow["@_rotWithShape"]);
     return {
       innerShadowColor,
       innerShadowOpacity,
       innerShadowBlur,
       innerShadowOffsetX,
-      innerShadowOffsetY
+      innerShadowOffsetY,
+      innerShadowRotateWithShape
     };
   }
   extractGlowStyle(shapeProps) {
@@ -8425,6 +8620,16 @@ var PptxShapeEffectStyleExtractor = class {
     const reflectionRotation = Number.isFinite(rotationRaw) ? rotationRaw / 6e4 : void 0;
     const distanceRaw = Number.parseInt(String(reflectionNode["@_dist"] || ""), 10);
     const reflectionDistance = Number.isFinite(distanceRaw) && distanceRaw >= 0 ? distanceRaw / this.context.emuPerPx : void 0;
+    const fadeDirRaw = parseIntAttr(reflectionNode["@_fadeDir"]);
+    const reflectionFadeDirection = fadeDirRaw !== void 0 ? fadeDirRaw / 6e4 : void 0;
+    const reflectionScaleX = parseIntAttr(reflectionNode["@_sx"]);
+    const reflectionScaleY = parseIntAttr(reflectionNode["@_sy"]);
+    const reflectionSkewX = parseIntAttr(reflectionNode["@_kx"]);
+    const reflectionSkewY = parseIntAttr(reflectionNode["@_ky"]);
+    const reflectionAlignment = parseAlignmentAttr(reflectionNode["@_algn"]);
+    const reflectionRotateWithShape = parseBoolAttr(reflectionNode["@_rotWithShape"]);
+    const stPosRaw = parseIntAttr(reflectionNode["@_stPos"]);
+    const reflectionStartPosition = stPosRaw !== void 0 ? stPosRaw / 1e5 : void 0;
     return {
       reflectionBlurRadius,
       reflectionStartOpacity,
@@ -8432,7 +8637,15 @@ var PptxShapeEffectStyleExtractor = class {
       reflectionEndPosition,
       reflectionDirection,
       reflectionRotation,
-      reflectionDistance
+      reflectionDistance,
+      reflectionFadeDirection,
+      reflectionScaleX,
+      reflectionScaleY,
+      reflectionSkewX,
+      reflectionSkewY,
+      reflectionAlignment,
+      reflectionRotateWithShape,
+      reflectionStartPosition
     };
   }
   extractBlurStyle(shapeProps) {
@@ -8484,11 +8697,56 @@ var PptxShapeEffectXmlBuilder = class {
         }
       }
     };
+    if (typeof shapeStyle.shadowScaleX === "number") {
+      xmlObj["@_sx"] = String(Math.round(shapeStyle.shadowScaleX));
+    }
+    if (typeof shapeStyle.shadowScaleY === "number") {
+      xmlObj["@_sy"] = String(Math.round(shapeStyle.shadowScaleY));
+    }
+    if (typeof shapeStyle.shadowSkewX === "number") {
+      xmlObj["@_kx"] = String(Math.round(shapeStyle.shadowSkewX));
+    }
+    if (typeof shapeStyle.shadowSkewY === "number") {
+      xmlObj["@_ky"] = String(Math.round(shapeStyle.shadowSkewY));
+    }
+    if (shapeStyle.shadowAlignment) {
+      xmlObj["@_algn"] = shapeStyle.shadowAlignment;
+    }
     if (typeof shapeStyle.shadowRotateWithShape === "boolean") {
       xmlObj["@_rotWithShape"] = shapeStyle.shadowRotateWithShape ? "1" : "0";
     }
     return xmlObj;
   }
+  buildPresetShadowXml(shapeStyle) {
+    const preset = shapeStyle.presetShadowName;
+    if (!preset || preset.length === 0) {
+      return void 0;
+    }
+    const shadowColor = String(shapeStyle.shadowColor || "#000000").trim();
+    const shadowOpacity = typeof shapeStyle.shadowOpacity === "number" && Number.isFinite(shapeStyle.shadowOpacity) ? this.context.clampUnitInterval(shapeStyle.shadowOpacity) : 0.5;
+    let distance;
+    let directionDegrees;
+    if (typeof shapeStyle.shadowAngle === "number" && typeof shapeStyle.shadowDistance === "number") {
+      directionDegrees = shapeStyle.shadowAngle;
+      distance = shapeStyle.shadowDistance;
+    } else {
+      const ox = typeof shapeStyle.shadowOffsetX === "number" ? shapeStyle.shadowOffsetX : 0;
+      const oy = typeof shapeStyle.shadowOffsetY === "number" ? shapeStyle.shadowOffsetY : 0;
+      distance = Math.sqrt(ox * ox + oy * oy);
+      directionDegrees = (Math.atan2(oy, ox) * 180 / Math.PI + 360) % 360;
+    }
+    return {
+      "@_prst": preset,
+      "@_dist": String(Math.round(distance * this.context.emuPerPx)),
+      "@_dir": String(Math.round(directionDegrees * 6e4)),
+      "a:srgbClr": {
+        "@_val": shadowColor.replace("#", ""),
+        "a:alpha": {
+          "@_val": String(Math.round(shadowOpacity * 1e5))
+        }
+      }
+    };
+  }
   buildInnerShadowXml(shapeStyle) {
     const innerColor = String(shapeStyle.innerShadowColor || "").trim();
     if (innerColor.length === 0 || innerColor === "transparent") {
@@ -8500,7 +8758,7 @@ var PptxShapeEffectXmlBuilder = class {
     const opacity = typeof shapeStyle.innerShadowOpacity === "number" && Number.isFinite(shapeStyle.innerShadowOpacity) ? this.context.clampUnitInterval(shapeStyle.innerShadowOpacity) : 0.5;
     const distance = Math.sqrt(offsetX * offsetX + offsetY * offsetY);
     const directionDegrees = (Math.atan2(offsetY, offsetX) * 180 / Math.PI + 360) % 360;
-    return {
+    const xmlObj = {
       "@_blurRad": String(Math.round(blurValue * this.context.emuPerPx)),
       "@_dist": String(Math.round(distance * this.context.emuPerPx)),
       "@_dir": String(Math.round(directionDegrees * 6e4)),
@@ -8511,6 +8769,10 @@ var PptxShapeEffectXmlBuilder = class {
         }
       }
     };
+    if (typeof shapeStyle.innerShadowRotateWithShape === "boolean") {
+      xmlObj["@_rotWithShape"] = shapeStyle.innerShadowRotateWithShape ? "1" : "0";
+    }
+    return xmlObj;
   }
   buildGlowXml(shapeStyle) {
     const glowColor = String(shapeStyle.glowColor || "").trim();
@@ -8572,6 +8834,30 @@ var PptxShapeEffectXmlBuilder = class {
         Math.round(shapeStyle.reflectionDistance * this.context.emuPerPx)
       );
     }
+    if (typeof shapeStyle.reflectionFadeDirection === "number") {
+      reflectionXml["@_fadeDir"] = String(Math.round(shapeStyle.reflectionFadeDirection * 6e4));
+    }
+    if (typeof shapeStyle.reflectionScaleX === "number") {
+      reflectionXml["@_sx"] = String(Math.round(shapeStyle.reflectionScaleX));
+    }
+    if (typeof shapeStyle.reflectionScaleY === "number") {
+      reflectionXml["@_sy"] = String(Math.round(shapeStyle.reflectionScaleY));
+    }
+    if (typeof shapeStyle.reflectionSkewX === "number") {
+      reflectionXml["@_kx"] = String(Math.round(shapeStyle.reflectionSkewX));
+    }
+    if (typeof shapeStyle.reflectionSkewY === "number") {
+      reflectionXml["@_ky"] = String(Math.round(shapeStyle.reflectionSkewY));
+    }
+    if (shapeStyle.reflectionAlignment) {
+      reflectionXml["@_algn"] = shapeStyle.reflectionAlignment;
+    }
+    if (typeof shapeStyle.reflectionRotateWithShape === "boolean") {
+      reflectionXml["@_rotWithShape"] = shapeStyle.reflectionRotateWithShape ? "1" : "0";
+    }
+    if (typeof shapeStyle.reflectionStartPosition === "number") {
+      reflectionXml["@_stPos"] = String(Math.round(shapeStyle.reflectionStartPosition * 1e5));
+    }
     return reflectionXml;
   }
   buildBlurXml(shapeStyle) {
@@ -8679,6 +8965,9 @@ var PptxShapeEffectXmlCodec = class {
   buildOuterShadowXml(shapeStyle) {
     return this.builder.buildOuterShadowXml(shapeStyle);
   }
+  buildPresetShadowXml(shapeStyle) {
+    return this.builder.buildPresetShadowXml(shapeStyle);
+  }
   buildInnerShadowXml(shapeStyle) {
     return this.builder.buildInnerShadowXml(shapeStyle);
   }
@@ -8839,6 +9128,9 @@ var PptxColorStyleCodec = class {
   buildOuterShadowXml(shapeStyle) {
     return this.shapeEffectXmlCodec.buildOuterShadowXml(shapeStyle);
   }
+  buildPresetShadowXml(shapeStyle) {
+    return this.shapeEffectXmlCodec.buildPresetShadowXml(shapeStyle);
+  }
   buildInnerShadowXml(shapeStyle) {
     return this.shapeEffectXmlCodec.buildInnerShadowXml(shapeStyle);
   }
@@ -8860,6 +9152,15 @@ var PptxColorStyleCodec = class {
   extractGradientFillColor(gradFill) {
     return this.gradientStyleCodec.extractGradientFillColor(gradFill);
   }
+  extractGradientFlip(gradFill) {
+    return this.gradientStyleCodec.extractGradientFlip(gradFill);
+  }
+  extractGradientRotWithShape(gradFill) {
+    return this.gradientStyleCodec.extractGradientRotWithShape(gradFill);
+  }
+  extractGradientScaled(gradFill) {
+    return this.gradientStyleCodec.extractGradientScaled(gradFill);
+  }
   extractGradientPathType(gradFill) {
     return this.gradientStyleCodec.extractGradientPathType(gradFill);
   }
@@ -8871,6 +9172,61 @@ var PptxColorStyleCodec = class {
   }
 };
 
+// src/core/utils/color-xml-preservation.ts
+var COLOR_CHOICE_KEYS = [
+  "a:srgbClr",
+  "a:schemeClr",
+  "a:sysClr",
+  "a:prstClr",
+  "a:scrgbClr",
+  "a:hslClr"
+];
+function extractColorChoiceXml(parent) {
+  if (!parent) {
+    return void 0;
+  }
+  for (const key of COLOR_CHOICE_KEYS) {
+    if (parent[key] !== void 0) {
+      return { [key]: parent[key] };
+    }
+  }
+  return void 0;
+}
+function normalizeHex(value) {
+  const raw = String(value ?? "").trim();
+  if (raw.length === 0) {
+    return "";
+  }
+  const hex = raw.replace(/^#/, "");
+  if (/^[0-9a-fA-F]{6}$/.test(hex)) {
+    return hex.toUpperCase();
+  }
+  return raw.toLowerCase();
+}
+function colorsEqual(left, right) {
+  if (left === void 0 || right === void 0) {
+    return false;
+  }
+  return normalizeHex(left) === normalizeHex(right);
+}
+function buildSrgbColorChoice(hex, opacity) {
+  const normalized = String(hex || "").replace(/^#/, "");
+  const srgb = { "@_val": normalized };
+  if (typeof opacity === "number" && Number.isFinite(opacity) && opacity >= 0 && opacity < 1) {
+    const alphaPct = Math.round(Math.max(0, Math.min(1, opacity)) * 1e5);
+    srgb["a:alpha"] = { "@_val": String(alphaPct) };
+  }
+  return { "a:srgbClr": srgb };
+}
+function serializeColorChoice(originalColorXml, currentResolvedHex, fallbackHex, opacity, options = {}) {
+  if (originalColorXml && colorsEqual(currentResolvedHex, fallbackHex)) {
+    if (options.preserveAlphaFromOriginal !== false) {
+      return originalColorXml;
+    }
+  }
+  return buildSrgbColorChoice(fallbackHex, opacity);
+}
+
 // src/core/core/builders/shape-style-3d-helpers.ts
 function applyScene3dStyle(shapeProps, style) {
   const scene3dNode = shapeProps["a:scene3d"];
@@ -8956,6 +9312,10 @@ function applyStrokeColor(lineNode, style, context) {
     const lineFill = lineNode["a:solidFill"];
     style.strokeColor = context.parseColor(lineFill);
     style.strokeOpacity = context.extractColorOpacity(lineFill);
+    const strokeColorXml = extractColorChoiceXml(lineFill);
+    if (strokeColorXml) {
+      style.strokeColorXml = strokeColorXml;
+    }
   } else if (lineNode["a:gradFill"]) {
     style.strokeColor = context.extractGradientFillColor(lineNode["a:gradFill"]);
     style.strokeOpacity = context.extractGradientOpacity(lineNode["a:gradFill"]);
@@ -9023,6 +9383,14 @@ function applyJoinCapCompound(lineNode, style) {
     style.lineJoin = "bevel";
   } else if ("a:miter" in lineNode) {
     style.lineJoin = "miter";
+    const miterNode = lineNode["a:miter"];
+    const limRaw = miterNode?.["@_lim"];
+    if (limRaw !== void 0 && limRaw !== "") {
+      const parsed = parseInt(String(limRaw), 10);
+      if (Number.isFinite(parsed)) {
+        style.miterLimit = parsed;
+      }
+    }
   }
   const capValue = String(lineNode["@_cap"] || "").trim().toLowerCase();
   if (capValue === "rnd" || capValue === "sq" || capValue === "flat") {
@@ -9079,6 +9447,10 @@ var PptxShapeStyleExtractor = class {
       style.fillMode = "solid";
       style.fillColor = this.context.parseColor(solidFill);
       style.fillOpacity = this.context.extractColorOpacity(solidFill);
+      const solidFillColorXml = extractColorChoiceXml(solidFill);
+      if (solidFillColorXml) {
+        style.fillColorXml = solidFillColorXml;
+      }
     } else if (gradFill) {
       style.fillMode = "gradient";
       style.fillColor = this.context.extractGradientFillColor(gradFill);
@@ -9090,6 +9462,18 @@ var PptxShapeStyleExtractor = class {
       style.fillGradientPathType = this.context.extractGradientPathType(gradFill);
       style.fillGradientFocalPoint = this.context.extractGradientFocalPoint(gradFill);
       style.fillGradientFillToRect = this.context.extractGradientFillToRect(gradFill);
+      const gradFlip = this.context.extractGradientFlip(gradFill);
+      if (gradFlip) {
+        style.fillGradientFlip = gradFlip;
+      }
+      const gradRot = this.context.extractGradientRotWithShape(gradFill);
+      if (gradRot !== void 0) {
+        style.fillGradientRotWithShape = gradRot;
+      }
+      const gradScaled = this.context.extractGradientScaled(gradFill);
+      if (gradScaled !== void 0) {
+        style.fillGradientScaled = gradScaled;
+      }
     } else if (pattFill) {
       style.fillMode = "pattern";
       style.fillColor = this.context.parseColor(pattFill["a:fgClr"]) || this.context.parseColor(pattFill["a:bgClr"]);
@@ -9171,10 +9555,45 @@ var PptxShapeStyleExtractor = class {
     if (styleNode?.["a:effectRef"]) {
       this.context.resolveThemeEffectRef(styleNode["a:effectRef"], style);
     }
+    const fontRef = styleNode?.["a:fontRef"];
+    if (fontRef) {
+      const idxAttr = String(fontRef["@_idx"] || "").trim();
+      if (idxAttr.length > 0) {
+        style.fontRefIdx = idxAttr;
+      }
+      const overrideColorXml = this.extractFontRefColorXml(fontRef);
+      if (overrideColorXml) {
+        style.fontRefColorXml = overrideColorXml;
+      }
+    }
     applyScene3dStyle(shapeProps, style);
     applyShape3dStyle(shapeProps, style, this.context);
     return style;
   }
+  /**
+   * Pull the verbatim colour-choice child out of an `a:fontRef` element,
+   * preserving any contained colour transforms for round-trip.
+   */
+  extractFontRefColorXml(refNode) {
+    if (!refNode) {
+      return void 0;
+    }
+    const keys = [
+      "a:scrgbClr",
+      "a:srgbClr",
+      "a:hslClr",
+      "a:sysClr",
+      "a:schemeClr",
+      "a:prstClr"
+    ];
+    for (const key of keys) {
+      const child = refNode[key];
+      if (child !== void 0) {
+        return { [key]: child };
+      }
+    }
+    return void 0;
+  }
   /**
    * Extract p14:hiddenFill from the shape properties extension list.
    * URI: {AF507438-7753-43E0-B8FC-AC1667EBCBE1}
@@ -9225,10 +9644,15 @@ var PptxShapeStyleExtractor = class {
 function applyCellFillStyle(cellProperties, style, context) {
   let hasStyle = false;
   if (cellProperties?.["a:solidFill"]) {
-    const fillColor = context.parseColor(cellProperties["a:solidFill"]);
+    const solidFillNode = cellProperties["a:solidFill"];
+    const fillColor = context.parseColor(solidFillNode);
     if (fillColor) {
       style.fillMode = "solid";
       style.backgroundColor = fillColor;
+      const bgColorXml = extractColorChoiceXml(solidFillNode);
+      if (bgColorXml) {
+        style.backgroundColorXml = bgColorXml;
+      }
       hasStyle = true;
     }
   }
@@ -9265,6 +9689,10 @@ function applyCellFillStyle(cellProperties, style, context) {
       }
     }
   }
+  if (cellProperties?.["a:noFill"] !== void 0) {
+    style.fillMode = "none";
+    hasStyle = true;
+  }
   if (cellProperties?.["a:pattFill"]) {
     const pattFill = cellProperties["a:pattFill"];
     const fgColor = context.parseColor(pattFill["a:fgClr"]);
@@ -9571,8 +9999,7 @@ var PptxTableDataParser = class {
         return width / totalWidthEmu;
       }) : gridColumns.map(() => 1 / Math.max(gridColumns.length, 1));
       const tableProperties = tableNode["a:tblPr"] || {};
-      const tableStyleNode = tableProperties["a:tblStyle"];
-      const tableStyleId = String(tableStyleNode?.["@_val"] || tableProperties["@_tblStyle"] || "").trim() || void 0;
+      const tableStyleId = this.extractTableStyleId(tableProperties);
       const xmlRows = this.context.ensureArray(tableNode["a:tr"]);
       const rows = xmlRows.map((rowNode) => {
         const rowHeightEmu = parseInt(String(rowNode?.["@_h"] || "0"), 10) || 0;
@@ -9607,6 +10034,28 @@ var PptxTableDataParser = class {
       return void 0;
     }
   }
+  /**
+   * Read the table style ID from `a:tblPr`.
+   *
+   * ECMA-376 §21.1.3.13 defines `<a:tableStyleId>{GUID}</a:tableStyleId>` as
+   * a child element of `a:tblPr` carrying the GUID as element text. Older
+   * inputs (and earlier versions of this library) used the legacy
+   * `<a:tblStyle val="{GUID}"/>` child element or a `@_tblStyle` attribute.
+   * Accept all three; the spec form takes precedence.
+   */
+  extractTableStyleId(tableProperties) {
+    const tableStyleIdNode = tableProperties["a:tableStyleId"];
+    if (tableStyleIdNode !== void 0 && tableStyleIdNode !== null) {
+      const direct = typeof tableStyleIdNode === "string" || typeof tableStyleIdNode === "number" ? String(tableStyleIdNode) : String(tableStyleIdNode["#text"] ?? "");
+      const trimmed = direct.trim();
+      if (trimmed.length > 0) {
+        return trimmed;
+      }
+    }
+    const tableStyleNode = tableProperties["a:tblStyle"];
+    const legacy = String(tableStyleNode?.["@_val"] || tableProperties["@_tblStyle"] || "").trim();
+    return legacy.length > 0 ? legacy : void 0;
+  }
   extractTableCellText(tableCell) {
     const paragraphs = this.context.ensureArray(tableCell?.["a:txBody"]?.["a:p"]);
     const lines = [];
@@ -9885,6 +10334,19 @@ var PptxGraphicFrameParser = class {
     if (graphicData["a:videoFile"] || graphicData["a:audioFile"] || uri.includes("/drawingml/2006/media")) {
       return "media";
     }
+    if (graphicData["aink:ink"] || uri.includes("/2010/ink") || uri.includes("drawing/2010/ink")) {
+      return "ink";
+    }
+    const alternateContent = graphicData["mc:AlternateContent"];
+    if (alternateContent) {
+      const choices = Array.isArray(alternateContent["mc:Choice"]) ? alternateContent["mc:Choice"] : alternateContent["mc:Choice"] ? [alternateContent["mc:Choice"]] : [];
+      for (const choice of choices) {
+        const requires = String(choice?.["@_Requires"] || "").toLowerCase();
+        if (requires.includes("aink") || choice?.["aink:ink"]) {
+          return "ink";
+        }
+      }
+    }
     return "unknown";
   }
 };
@@ -10786,6 +11248,7 @@ var PptxDocumentPropertiesUpdater = class {
     }));
     if (sanitized.length === 0) {
       this.context.zip.remove("docProps/custom.xml");
+      await this.removeCustomPropertiesPackagingArtifacts();
       return;
     }
     const customXml = {
@@ -10805,6 +11268,116 @@ var PptxDocumentPropertiesUpdater = class {
       }
     };
     this.context.zip.file("docProps/custom.xml", this.context.builder.build(customXml));
+    await this.ensureCustomPropertiesPackagingArtifacts();
+  }
+  /**
+   * Ensure `[Content_Types].xml` has an `Override` for `docProps/custom.xml`
+   * and the root `_rels/.rels` references it (ECMA-376 §15.2.12.2 +
+   * Part 2 §10.1.2.5). Without these, the package fails OPC validation
+   * and Office strips the custom properties on next save.
+   */
+  async ensureCustomPropertiesPackagingArtifacts() {
+    const customContentType = "application/vnd.openxmlformats-officedocument.custom-properties+xml";
+    const customRelType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties";
+    const ctFile = this.context.zip.file("[Content_Types].xml");
+    if (ctFile) {
+      try {
+        const ctXml = await ctFile.async("string");
+        const ctData = this.context.parser.parse(ctXml);
+        const types = ctData["Types"];
+        if (types) {
+          const overrides = Array.isArray(types["Override"]) ? types["Override"] : types["Override"] ? [types["Override"]] : [];
+          const hasCustomOverride = overrides.some(
+            (o) => String(o?.["@_PartName"] || "") === "/docProps/custom.xml"
+          );
+          if (!hasCustomOverride) {
+            overrides.push({
+              "@_PartName": "/docProps/custom.xml",
+              "@_ContentType": customContentType
+            });
+            types["Override"] = overrides.length === 1 ? overrides[0] : overrides;
+            this.context.zip.file("[Content_Types].xml", this.context.builder.build(ctData));
+          }
+        }
+      } catch (error) {
+        console.warn("Failed to update [Content_Types].xml for custom properties:", error);
+      }
+    }
+    const relsFile = this.context.zip.file("_rels/.rels");
+    if (relsFile) {
+      try {
+        const relsXml = await relsFile.async("string");
+        const relsData = this.context.parser.parse(relsXml);
+        const relationships = relsData["Relationships"];
+        if (relationships) {
+          const rels = Array.isArray(relationships["Relationship"]) ? relationships["Relationship"] : relationships["Relationship"] ? [relationships["Relationship"]] : [];
+          const hasCustomRel = rels.some((r) => String(r?.["@_Type"] || "") === customRelType);
+          if (!hasCustomRel) {
+            let maxId = 0;
+            for (const rel of rels) {
+              const id = String(rel?.["@_Id"] || "");
+              const num = Number.parseInt(id.replace(/^rId/, ""), 10);
+              if (Number.isFinite(num) && num > maxId) {
+                maxId = num;
+              }
+            }
+            rels.push({
+              "@_Id": `rId${maxId + 1}`,
+              "@_Type": customRelType,
+              "@_Target": "docProps/custom.xml"
+            });
+            relationships["Relationship"] = rels;
+            this.context.zip.file("_rels/.rels", this.context.builder.build(relsData));
+          }
+        }
+      } catch (error) {
+        console.warn("Failed to update _rels/.rels for custom properties:", error);
+      }
+    }
+  }
+  /**
+   * Remove the Override + root rel for `docProps/custom.xml` when the
+   * caller has emptied custom properties so the package doesn't keep an
+   * orphan content-type entry referencing a deleted part.
+   */
+  async removeCustomPropertiesPackagingArtifacts() {
+    const customRelType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties";
+    const ctFile = this.context.zip.file("[Content_Types].xml");
+    if (ctFile) {
+      try {
+        const ctXml = await ctFile.async("string");
+        const ctData = this.context.parser.parse(ctXml);
+        const types = ctData["Types"];
+        if (types) {
+          const overrides = Array.isArray(types["Override"]) ? types["Override"] : types["Override"] ? [types["Override"]] : [];
+          const filtered = overrides.filter(
+            (o) => String(o?.["@_PartName"] || "") !== "/docProps/custom.xml"
+          );
+          if (filtered.length !== overrides.length) {
+            types["Override"] = filtered.length === 1 ? filtered[0] : filtered;
+            this.context.zip.file("[Content_Types].xml", this.context.builder.build(ctData));
+          }
+        }
+      } catch {
+      }
+    }
+    const relsFile = this.context.zip.file("_rels/.rels");
+    if (relsFile) {
+      try {
+        const relsXml = await relsFile.async("string");
+        const relsData = this.context.parser.parse(relsXml);
+        const relationships = relsData["Relationships"];
+        if (relationships) {
+          const rels = Array.isArray(relationships["Relationship"]) ? relationships["Relationship"] : relationships["Relationship"] ? [relationships["Relationship"]] : [];
+          const filtered = rels.filter((r) => String(r?.["@_Type"] || "") !== customRelType);
+          if (filtered.length !== rels.length) {
+            relationships["Relationship"] = filtered;
+            this.context.zip.file("_rels/.rels", this.context.builder.build(relsData));
+          }
+        }
+      } catch {
+      }
+    }
   }
   normalizeCustomPropertyType(type) {
     const supportedTypes = /* @__PURE__ */ new Set([
@@ -11148,6 +11721,7 @@ var PptxSlideLoaderService = class {
     await params.loadSlideRelationships(path2, slideRelsPath);
     const clrMapOverride = params.parseSlideClrMapOverride(slideXmlObj);
     params.setCurrentSlideClrMapOverride(clrMapOverride);
+    await params.setActiveMasterForSlide?.(path2);
     let restoreThemeOverride;
     try {
       const layoutPathForOverride = params.findLayoutPathForSlide(path2);
@@ -15899,6 +16473,20 @@ var AXIS_TYPE_MAP = {
   dateAx: "dateAx",
   serAx: "serAx"
 };
+function upsertChartAxisChild(parent, localName, value, getLocalName) {
+  const existingKey = Object.keys(parent).find((k) => getLocalName(k) === localName);
+  if (value === void 0) {
+    if (existingKey) {
+      delete parent[existingKey];
+    }
+    return;
+  }
+  if (existingKey) {
+    parent[existingKey]["@_val"] = value;
+  } else {
+    parent[`c:${localName}`] = { "@_val": value };
+  }
+}
 function parseChartAxes(plotArea, xmlLookup, colorParser, getLocalName) {
   const result = [];
   for (const key of Object.keys(plotArea)) {
@@ -16019,6 +16607,27 @@ function parseSingleAxis(axisNode, axisType, xmlLookup, colorParser) {
   if (dispUnitsNode) {
     parseDisplayUnits(dispUnitsNode, xmlLookup, result);
   }
+  const majorUnitNode = xmlLookup.getChildByLocalName(axisNode, "majorUnit");
+  if (majorUnitNode) {
+    const majorVal = parseFloat(String(majorUnitNode["@_val"]));
+    if (Number.isFinite(majorVal)) {
+      result.majorUnit = majorVal;
+    }
+  }
+  const minorUnitNode = xmlLookup.getChildByLocalName(axisNode, "minorUnit");
+  if (minorUnitNode) {
+    const minorVal = parseFloat(String(minorUnitNode["@_val"]));
+    if (Number.isFinite(minorVal)) {
+      result.minorUnit = minorVal;
+    }
+  }
+  const tickLblPosNode = xmlLookup.getChildByLocalName(axisNode, "tickLblPos");
+  if (tickLblPosNode) {
+    const v = String(tickLblPosNode["@_val"] || "").trim();
+    if (v === "high" || v === "low" || v === "nextTo" || v === "none") {
+      result.tickLblPos = v;
+    }
+  }
   return result;
 }
 var VALID_DISPLAY_UNITS = /* @__PURE__ */ new Set([
@@ -17330,23 +17939,55 @@ var SHAPE_TREE_ELEMENT_TAGS = /* @__PURE__ */ new Set([
   "p16:model3D",
   ...VML_SHAPE_TAGS
 ]);
+function diagnoseSelection(ac) {
+  const choices = ensureArray2(ac["mc:Choice"]);
+  for (let i = 0; i < choices.length; i++) {
+    const choice = choices[i];
+    const requires = String(choice?.["@_Requires"] ?? "").trim();
+    if (requires.length === 0 || areNamespacesSupported(requires)) {
+      const resolved = resolveNestedAlternateContent(choice);
+      return { branch: "choice", choiceIndex: i, resolved };
+    }
+  }
+  const fallback = ac["mc:Fallback"];
+  if (fallback) {
+    return { branch: "fallback", resolved: resolveNestedAlternateContent(fallback) };
+  }
+  return void 0;
+}
 function unwrapAlternateContent(container) {
   const altContents = ensureArray2(container["mc:AlternateContent"]);
   if (altContents.length === 0) {
-    return;
+    return [];
   }
+  const blocks = [];
   for (const ac of altContents) {
-    const branch = selectAlternateContentBranch(ac);
-    if (!branch) {
+    const diagnosis = diagnoseSelection(ac);
+    if (!diagnosis) {
       continue;
     }
+    const block = {
+      rawAc: ac,
+      selectedBranch: diagnosis.branch,
+      choiceIndex: diagnosis.branch === "choice" ? diagnosis.choiceIndex : void 0,
+      childRefs: []
+    };
+    const branch = diagnosis.resolved;
     for (const tag of SHAPE_TREE_ELEMENT_TAGS) {
       const children = ensureArray2(branch[tag]);
       if (children.length > 0) {
         container[tag] = [...ensureArray2(container[tag]), ...children];
+        for (const child of children) {
+          block.childRefs.push({ tag, node: child });
+        }
       }
     }
+    if (block.childRefs.length > 0) {
+      blocks.push(block);
+    }
   }
+  delete container["mc:AlternateContent"];
+  return blocks;
 }
 function ensureArray2(val) {
   if (!val) {
@@ -17358,7 +17999,7 @@ function ensureArray2(val) {
 
 // src/core/utils/body-properties-parser.ts
 function parseBodyPrBooleanAttrs(bodyPr, textStyle) {
-  const parseBoolAttr = (attr) => {
+  const parseBoolAttr2 = (attr) => {
     const raw = bodyPr[attr];
     if (raw === void 0) {
       return void 0;
@@ -17366,19 +18007,19 @@ function parseBodyPrBooleanAttrs(bodyPr, textStyle) {
     const val = String(raw).trim().toLowerCase();
     return val === "1" || val === "true";
   };
-  const compatLnSpc = parseBoolAttr("@_compatLnSpc");
+  const compatLnSpc = parseBoolAttr2("@_compatLnSpc");
   if (compatLnSpc !== void 0) {
     textStyle.compatibleLineSpacing = compatLnSpc;
   }
-  const forceAA = parseBoolAttr("@_forceAA");
+  const forceAA = parseBoolAttr2("@_forceAA");
   if (forceAA !== void 0) {
     textStyle.forceAntiAlias = forceAA;
   }
-  const upright = parseBoolAttr("@_upright");
+  const upright = parseBoolAttr2("@_upright");
   if (upright !== void 0) {
     textStyle.upright = upright;
   }
-  const fromWordArt = parseBoolAttr("@_fromWordArt");
+  const fromWordArt = parseBoolAttr2("@_fromWordArt");
   if (fromWordArt !== void 0) {
     textStyle.fromWordArt = fromWordArt;
   }
@@ -17401,46 +18042,6 @@ function writeBodyPrBooleanAttrs(bodyPr, textStyle) {
   }
 }
 
-// src/core/utils/theme-override-utils.ts
-var COLOR_MAP_ALIAS_KEYS = [
-  "bg1",
-  "tx1",
-  "bg2",
-  "tx2",
-  "accent1",
-  "accent2",
-  "accent3",
-  "accent4",
-  "accent5",
-  "accent6",
-  "hlink",
-  "folHlink"
-];
-var DEFAULT_COLOR_MAP = {
-  bg1: "lt1",
-  tx1: "dk1",
-  bg2: "lt2",
-  tx2: "dk2",
-  accent1: "accent1",
-  accent2: "accent2",
-  accent3: "accent3",
-  accent4: "accent4",
-  accent5: "accent5",
-  accent6: "accent6",
-  hlink: "hlink",
-  folHlink: "folHlink"
-};
-function buildClrMapOverrideXml(override) {
-  if (!override || Object.keys(override).length === 0) {
-    return { "a:masterClrMapping": {} };
-  }
-  const attrs2 = {};
-  for (const key of COLOR_MAP_ALIAS_KEYS) {
-    attrs2[`@_${key}`] = override[key] ?? DEFAULT_COLOR_MAP[key];
-  }
-  return { "a:overrideClrMapping": attrs2 };
-}
-
 // src/core/utils/data-url-utils.ts
 function parseDataUrlToBytes(dataUrl) {
   const match = dataUrl.match(/^data:([^;]+);base64,(.+)$/);
@@ -17538,6 +18139,46 @@ async function fetchUrlToBytes(url) {
   }
 }
 
+// src/core/utils/theme-override-utils.ts
+var COLOR_MAP_ALIAS_KEYS = [
+  "bg1",
+  "tx1",
+  "bg2",
+  "tx2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+];
+var DEFAULT_COLOR_MAP = {
+  bg1: "lt1",
+  tx1: "dk1",
+  bg2: "lt2",
+  tx2: "dk2",
+  accent1: "accent1",
+  accent2: "accent2",
+  accent3: "accent3",
+  accent4: "accent4",
+  accent5: "accent5",
+  accent6: "accent6",
+  hlink: "hlink",
+  folHlink: "folHlink"
+};
+function buildClrMapOverrideXml(override) {
+  if (!override || Object.keys(override).length === 0) {
+    return { "a:masterClrMapping": {} };
+  }
+  const attrs2 = {};
+  for (const key of COLOR_MAP_ALIAS_KEYS) {
+    attrs2[`@_${key}`] = override[key] ?? DEFAULT_COLOR_MAP[key];
+  }
+  return { "a:overrideClrMapping": attrs2 };
+}
+
 // src/core/utils/encryption-detection.ts
 var OLE_MAGIC = new Uint8Array([208, 207, 17, 224, 161, 27, 26, 225]);
 var ZIP_MAGIC = new Uint8Array([80, 75]);
@@ -23300,7 +23941,7 @@ function parseActiveXControlsFromSlide(slideXml2) {
 }
 
 // src/core/utils/theme-switching.ts
-function normalizeHex(hex) {
+function normalizeHex2(hex) {
   if (!hex) {
     return "";
   }
@@ -23310,8 +23951,8 @@ function buildColorRemapTable(oldColorMap, newColorMap) {
   const remap = /* @__PURE__ */ new Map();
   const allKeys = [...THEME_COLOR_SCHEME_KEYS, "tx1", "bg1", "tx2", "bg2"];
   for (const key of allKeys) {
-    const oldVal = normalizeHex(oldColorMap[key]);
-    const newVal = normalizeHex(newColorMap[key]);
+    const oldVal = normalizeHex2(oldColorMap[key]);
+    const newVal = normalizeHex2(newColorMap[key]);
     if (oldVal && newVal && oldVal !== newVal) {
       remap.set(oldVal, `#${newVal}`);
       remap.set(`#${oldVal}`, `#${newVal}`);
@@ -23323,7 +23964,7 @@ function remapColor(color, remap) {
   if (!color) {
     return color;
   }
-  const normalized = normalizeHex(color);
+  const normalized = normalizeHex2(color);
   const remapped = remap.get(normalized) ?? remap.get(`#${normalized}`);
   return remapped ?? color;
 }
@@ -23463,7 +24104,7 @@ function remapSlideColors(slide, remap) {
 function buildThemeColorMap(colorScheme) {
   const map = {};
   for (const key of THEME_COLOR_SCHEME_KEYS) {
-    map[key] = normalizeHex(colorScheme[key]);
+    map[key] = normalizeHex2(colorScheme[key]);
   }
   map.tx1 = map.dk1;
   map.bg1 = map.lt1;
@@ -23499,8 +24140,11 @@ function applyThemeToData(data, newColorScheme, newFontScheme, themeName) {
 
 // src/core/core/runtime/PptxHandlerRuntimeSaveParagraphHelpers.ts
 var EMU_PER_PX4 = 9525;
-function buildParagraphPropertiesXml(textStyle, paragraphAlign, bulletInfo, spacing) {
+function buildParagraphPropertiesXml(textStyle, paragraphAlign, bulletInfo, spacing, level) {
   const paragraphProps = {};
+  if (typeof level === "number" && Number.isFinite(level) && level > 0) {
+    paragraphProps["@_lvl"] = String(Math.min(Math.max(Math.round(level), 0), 8));
+  }
   if (paragraphAlign) {
     paragraphProps["@_algn"] = paragraphAlign;
   }
@@ -23572,23 +24216,28 @@ function applyBulletProperties(paragraphProps, bulletInfo) {
     paragraphProps["a:buNone"] = {};
     return;
   }
-  if (bulletInfo.color) {
+  if (bulletInfo.colorInherit) {
+    paragraphProps["a:buClrTx"] = {};
+  } else if (bulletInfo.color) {
     const colorHex = bulletInfo.color.replace("#", "");
     paragraphProps["a:buClr"] = {
       "a:srgbClr": { "@_val": colorHex }
     };
   }
-  if (bulletInfo.sizePercent !== void 0) {
+  if (bulletInfo.sizeInherit) {
+    paragraphProps["a:buSzTx"] = {};
+  } else if (bulletInfo.sizePercent !== void 0) {
     paragraphProps["a:buSzPct"] = {
       "@_val": String(Math.round(bulletInfo.sizePercent * 1e3))
     };
-  }
-  if (bulletInfo.sizePts !== void 0) {
+  } else if (bulletInfo.sizePts !== void 0) {
     paragraphProps["a:buSzPts"] = {
       "@_val": String(Math.round(bulletInfo.sizePts * 100))
     };
   }
-  if (bulletInfo.fontFamily) {
+  if (bulletInfo.fontInherit) {
+    paragraphProps["a:buFontTx"] = {};
+  } else if (bulletInfo.fontFamily) {
     paragraphProps["a:buFont"] = {
       "@_typeface": bulletInfo.fontFamily
     };
@@ -23611,7 +24260,7 @@ function applyBulletProperties(paragraphProps, bulletInfo) {
     };
   }
 }
-function assembleParagraphXml(runs, paragraphProps) {
+function assembleParagraphXml(runs, paragraphProps, endParaRunProperties) {
   const paragraph = {
     "a:pPr": paragraphProps
   };
@@ -23633,7 +24282,11 @@ function assembleParagraphXml(runs, paragraphProps) {
   if (cleanRegularRuns.length === 0 && fieldRuns.length === 0) {
     paragraph["a:r"] = runs.length > 1 ? runs : runs[0];
   }
-  paragraph["a:endParaRPr"] = { "@_lang": "en-US" };
+  if (endParaRunProperties && typeof endParaRunProperties === "object") {
+    paragraph["a:endParaRPr"] = endParaRunProperties;
+  } else {
+    paragraph["a:endParaRPr"] = { "@_lang": "en-US" };
+  }
   return paragraph;
 }
 function computeUniformSegmentOverrides(textStyle, textSegments) {
@@ -23937,6 +24590,140 @@ var PptxHandlerRuntime = class {
    * `p:clrMapOvr / a:overrideClrMapping`.
    */
   currentSlideClrMapOverride = null;
+  /**
+   * Per-master colour map alias dictionaries parsed from each master's
+   * `<p:clrMap>` element (e.g. `bg1 → lt1`, `tx1 → dk1`, `accent1 → accent1`).
+   *
+   * `clrMap` is the *aliasing* layer between logical colour names used in
+   * DrawingML and the raw theme scheme slots. Per ECMA-376 §19.3.1.7 it
+   * lives on each `p:sldMaster`, and slide layouts/slides may further
+   * override it via `p:clrMapOvr`. Resolution must happen at colour-lookup
+   * time, *not* by baking it into {@link themeColorMap}.
+   *
+   * Phase 2 Stream B / C-H4.
+   */
+  masterClrMaps = /* @__PURE__ */ new Map();
+  /**
+   * Per-master theme color maps. Each master may reference its own theme
+   * file via `_rels/slideMasterN.xml.rels`. For multi-master decks, slides
+   * must resolve scheme colours against their *own* master's theme.
+   *
+   * Falls back to {@link themeColorMap} when a master entry is missing.
+   *
+   * Phase 2 Stream B / C-H4.
+   */
+  masterThemeColorMaps = /* @__PURE__ */ new Map();
+  /**
+   * Per-master theme font maps. Same rationale as
+   * {@link masterThemeColorMaps}: multi-master decks may have one font
+   * scheme per theme.
+   */
+  masterThemeFontMaps = /* @__PURE__ */ new Map();
+  /**
+   * Per-master format schemes (fmtScheme). For multi-master decks each
+   * master's slides should resolve fill/line/effect refs against the
+   * matrix from that master's theme.
+   */
+  masterThemeFormatSchemes = /* @__PURE__ */ new Map();
+  /**
+   * Per-master mapping from slide-master path to the theme path it
+   * references via `_rels/slideMasterN.xml.rels`. Populated by
+   * {@link loadPerMasterThemes} during load. Used by the save-side
+   * theme writer to know which themeN.xml to (re)emit for each master.
+   *
+   * Phase 4 Stream A / C-H3.
+   */
+  masterThemePaths = /* @__PURE__ */ new Map();
+  /**
+   * Per-script font tables for major and minor fonts. Captured per master
+   * theme. Keys are master paths; values map `mj`/`mn` -> script tag (e.g.
+   * `Hans`, `Hant`, `Arab`, `Hebr`, `Thai`, `Beng`, …) -> typeface name.
+   *
+   * Phase 4 Stream A / M4.
+   */
+  masterThemeMajorFontScripts = /* @__PURE__ */ new Map();
+  masterThemeMinorFontScripts = /* @__PURE__ */ new Map();
+  /**
+   * Theme name attribute (`<a:theme @name>`) per master theme path.
+   * Captured for byte-stable round-trip.
+   */
+  masterThemeNames = /* @__PURE__ */ new Map();
+  /**
+   * `<a:fontScheme @name>` per master theme path.
+   */
+  masterThemeFontSchemeNames = /* @__PURE__ */ new Map();
+  /**
+   * `<a:clrScheme @name>` per master theme path.
+   */
+  masterThemeColorSchemeNames = /* @__PURE__ */ new Map();
+  /**
+   * Raw original theme XML keyed by theme path. Captured at load-time.
+   * Used by the save pipeline to passthrough the full theme XML when no
+   * in-memory mutation has occurred — preserving fillStyleLst /
+   * lnStyleLst / effectStyleLst / bgFillStyleLst /
+   * extraClrSchemeLst / objectDefaults / extLst exactly as written.
+   *
+   * Phase 4 Stream A / C-H3.
+   */
+  originalThemeXmlByPath = /* @__PURE__ */ new Map();
+  /**
+   * Set of theme paths whose in-memory state has been mutated since
+   * load. Saving a theme path that's NOT dirty is a no-op (the original
+   * file already exists in the ZIP). Saving a dirty theme path
+   * regenerates the part from in-memory state.
+   *
+   * Phase 4 Stream A / C-H3.
+   */
+  dirtyThemePaths = /* @__PURE__ */ new Set();
+  /**
+   * Per-master parsed `<p:txStyles>` (titleStyle/bodyStyle/otherStyle).
+   * Populated by {@link enrichSlideMastersWithTxStyles} during load so the
+   * inheritance chain can find the master text-style cascade without
+   * re-parsing master XML on every lookup. Phase 4 Stream B / P-H1.
+   */
+  masterTxStylesCache = /* @__PURE__ */ new Map();
+  /**
+   * Captured `<a:objectDefaults>` snapshot per master theme path. The
+   * full ECMA-376 inheritance chain (master / layout / placeholder /
+   * objectDefaults) is non-trivial; we store the raw spDef/lnDef/txDef
+   * subtrees and re-emit them verbatim for round-trip.
+   *
+   * Phase 4 Stream A / M5.
+   */
+  masterThemeObjectDefaults = /* @__PURE__ */ new Map();
+  /**
+   * Captured `<a:extraClrSchemeLst>` raw subtree per master theme path
+   * for verbatim round-trip.
+   *
+   * Phase 4 Stream A.
+   */
+  masterThemeExtraClrSchemeLst = /* @__PURE__ */ new Map();
+  /**
+   * Captured `<a:custClrLst>` raw subtree per master theme path
+   * for verbatim round-trip.
+   *
+   * Phase 4 Stream A.
+   */
+  masterThemeCustClrLst = /* @__PURE__ */ new Map();
+  /**
+   * Captured theme-level `<a:extLst>` raw subtree per master theme path.
+   */
+  masterThemeExtLst = /* @__PURE__ */ new Map();
+  /**
+   * Active master's clrMap for the slide currently being parsed.  Walked
+   * after `currentSlideClrMapOverride` (slide and layout overrides take
+   * precedence). `null` means "fall through to themeColorMap directly".
+   */
+  currentMasterClrMap = null;
+  /**
+   * Snapshot of the global theme state taken right after
+   * {@link loadThemeData} completes. Used as the fallback when a slide's
+   * master has no per-master theme entry, so per-slide multi-master
+   * switching does not leak the previous slide's master state.
+   */
+  globalThemeColorMapSnapshot = {};
+  globalThemeFontMapSnapshot = {};
+  globalThemeFormatSchemeSnapshot;
   /** Thumbnail image data from `docProps/thumbnail.jpeg` preserved for round-trip. */
   thumbnailData = null;
   /** Raw VBA project binary preserved for macro-enabled (.pptm) round-trip. */
@@ -23947,6 +24734,19 @@ var PptxHandlerRuntime = class {
   signatureDetection = null;
   /** Custom XML data parts parsed from `customXml/` in the OPC package. */
   customXmlParts = [];
+  /**
+   * Maps an element's `rawXml` reference to the `mc:AlternateContent`
+   * envelope that originally wrapped it (CC-4).  Populated during slide
+   * (and `p:grpSp`) parsing; consulted at save time to re-emit the
+   * original `<mc:Choice>` / `<mc:Fallback>` shape so legacy renderers
+   * keep their fallback content.
+   *
+   * Multiple sibling elements may share the same `AlternateContentBlock`
+   * value (a single AC envelope often wraps several child shapes — e.g.
+   * `p14:media` + its `p:pic` fallback nest one each).  WeakMap so AC
+   * envelopes are GC'd if the parsed XmlObject is dropped.
+   */
+  alternateContentBlockByRawXml = /* @__PURE__ */ new WeakMap();
   /** Embedded fonts extracted during load, preserved for automatic re-embedding on save. */
   loadedEmbeddedFonts = [];
   /** Map of comment author IDs to display names (from `ppt/commentAuthors.xml`). */
@@ -25760,7 +26560,12 @@ var PptxHandlerRuntime9 = class extends PptxHandlerRuntime8 {
       const bgColor = this.parseBackgroundColor(bg);
       const spTree = master["p:cSld"]?.["p:spTree"];
       const placeholders = this.extractPlaceholderList(spTree);
-      return { path: path2, backgroundColor: bgColor, placeholders };
+      const result = { path: path2, backgroundColor: bgColor, placeholders };
+      const hf = parseHeaderFooterFlags(master["p:hf"]);
+      if (hf) {
+        result.headerFooter = hf;
+      }
+      return result;
     } catch (e) {
       console.warn("Failed to parse handout master:", e);
       return void 0;
@@ -25786,7 +26591,12 @@ var PptxHandlerRuntime9 = class extends PptxHandlerRuntime8 {
       const bgColor = this.parseBackgroundColor(bg);
       const spTree = master["p:cSld"]?.["p:spTree"];
       const placeholders = this.extractPlaceholderList(spTree);
-      return { path: path2, backgroundColor: bgColor, placeholders };
+      const result = { path: path2, backgroundColor: bgColor, placeholders };
+      const hf = parseHeaderFooterFlags(master["p:hf"]);
+      if (hf) {
+        result.headerFooter = hf;
+      }
+      return result;
     } catch (e) {
       console.warn("Failed to parse notes master:", e);
       return void 0;
@@ -25831,6 +26641,10 @@ var PptxHandlerRuntime9 = class extends PptxHandlerRuntime8 {
         const uVal = String(userDrawn).trim().toLowerCase();
         layout.userDrawn = uVal === "1" || uVal === "true";
       }
+      const hf = parseHeaderFooterFlags(sldLayout["p:hf"]);
+      if (hf) {
+        layout.headerFooter = hf;
+      }
       const clrMapOvr = sldLayout["p:clrMapOvr"];
       if (clrMapOvr && clrMapOvr["a:masterClrMapping"] === void 0) {
         const overrideNode = clrMapOvr["a:overrideClrMapping"];
@@ -26436,6 +27250,18 @@ function buildClrChangeNode(style) {
 }
 
 // src/core/core/runtime/PptxHandlerRuntimeSaveRunProperties.ts
+function applyFontMetadata(fontNode, panose, pitchFamily, charset) {
+  if (panose && panose.length > 0) {
+    fontNode["@_panose"] = panose;
+  }
+  if (typeof pitchFamily === "number" && Number.isFinite(pitchFamily)) {
+    fontNode["@_pitchFamily"] = String(pitchFamily);
+  }
+  if (typeof charset === "number" && Number.isFinite(charset)) {
+    fontNode["@_charset"] = String(charset);
+  }
+  return fontNode;
+}
 var PptxHandlerRuntime12 = class _PptxHandlerRuntime extends PptxHandlerRuntime11 {
   createRunPropertiesFromTextStyle(style, resolveHyperlinkRelationshipId) {
     const runProps = {
@@ -26493,6 +27319,12 @@ var PptxHandlerRuntime12 = class _PptxHandlerRuntime extends PptxHandlerRuntime1
     if (style.bookmark) {
       runProps["@_bmk"] = style.bookmark;
     }
+    if (style.altLanguage) {
+      runProps["@_altLang"] = style.altLanguage;
+    }
+    if (typeof style.smartTagId === "number" && Number.isFinite(style.smartTagId)) {
+      runProps["@_smtId"] = String(style.smartTagId);
+    }
     if (style.textOutlineWidth || style.textOutlineColor) {
       const lnObj = {};
       if (typeof style.textOutlineWidth === "number" && style.textOutlineWidth > 0) {
@@ -26508,11 +27340,12 @@ var PptxHandlerRuntime12 = class _PptxHandlerRuntime extends PptxHandlerRuntime1
       runProps["a:ln"] = lnObj;
     }
     if (style.color) {
-      runProps["a:solidFill"] = {
-        "a:srgbClr": {
-          "@_val": style.color.replace("#", "")
-        }
-      };
+      const resolvedOriginalColor = style.colorXml ? this.parseColor(style.colorXml) : void 0;
+      runProps["a:solidFill"] = serializeColorChoice(
+        style.colorXml,
+        resolvedOriginalColor,
+        style.color
+      );
     } else if (style.textFillGradientStops && style.textFillGradientStops.length > 0) {
       const gradStops = style.textFillGradientStops.filter((stop) => Boolean(stop?.color)).map((stop) => {
         const rawPos = (stop.position ?? 0) / 100;
@@ -26585,16 +27418,32 @@ var PptxHandlerRuntime12 = class _PptxHandlerRuntime extends PptxHandlerRuntime1
       };
     }
     if (style.fontFamily) {
-      runProps["a:latin"] = { "@_typeface": style.fontFamily };
-      runProps["a:ea"] = {
-        "@_typeface": style.eastAsiaFont || style.fontFamily
-      };
-      runProps["a:cs"] = {
-        "@_typeface": style.complexScriptFont || style.fontFamily
-      };
+      runProps["a:latin"] = applyFontMetadata(
+        { "@_typeface": style.fontFamily },
+        style.latinFontPanose,
+        style.latinFontPitchFamily,
+        style.latinFontCharset
+      );
+      runProps["a:ea"] = applyFontMetadata(
+        { "@_typeface": style.eastAsiaFont || style.fontFamily },
+        style.eastAsiaFontPanose,
+        style.eastAsiaFontPitchFamily,
+        style.eastAsiaFontCharset
+      );
+      runProps["a:cs"] = applyFontMetadata(
+        { "@_typeface": style.complexScriptFont || style.fontFamily },
+        style.complexScriptFontPanose,
+        style.complexScriptFontPitchFamily,
+        style.complexScriptFontCharset
+      );
     }
     if (style.symbolFont) {
-      runProps["a:sym"] = { "@_typeface": style.symbolFont };
+      runProps["a:sym"] = applyFontMetadata(
+        { "@_typeface": style.symbolFont },
+        style.symbolFontPanose,
+        style.symbolFontPitchFamily,
+        style.symbolFontCharset
+      );
     }
     if (style.hyperlink && resolveHyperlinkRelationshipId) {
       const hyperlinkTarget = String(style.hyperlink).trim();
@@ -26669,14 +27518,15 @@ var PptxHandlerRuntime13 = class extends PptxHandlerRuntime12 {
       lineSpacing: this.createLineSpacingXmlFromMultiplier(textStyle?.lineSpacing),
       lineSpacingExactPt: textStyle?.lineSpacingExactPt
     };
-    const createParagraph = (runs, bulletInfo) => {
+    const createParagraph = (runs, bulletInfo, level, endParaRunProperties) => {
       const paragraphProps = buildParagraphPropertiesXml(
         textStyle,
         paragraphAlign,
         bulletInfo,
-        spacing
+        spacing,
+        level
       );
-      return assembleParagraphXml(runs, paragraphProps);
+      return assembleParagraphXml(runs, paragraphProps, endParaRunProperties);
     };
     const createRun = (runText, style) => ({
       "a:rPr": this.createRunPropertiesFromTextStyle(style, resolveHyperlinkRelationshipId),
@@ -26724,13 +27574,19 @@ var PptxHandlerRuntime13 = class extends PptxHandlerRuntime12 {
     const paragraphs = [];
     let currentRuns = [];
     let currentBulletInfo;
+    let currentLevel;
+    let currentEndParaRunProperties;
     const pushParagraph = () => {
       if (currentRuns.length === 0) {
         currentRuns.push(createRun("", textStyle));
       }
-      paragraphs.push(createParagraph(currentRuns, currentBulletInfo));
+      paragraphs.push(
+        createParagraph(currentRuns, currentBulletInfo, currentLevel, currentEndParaRunProperties)
+      );
       currentRuns = [];
       currentBulletInfo = void 0;
+      currentLevel = void 0;
+      currentEndParaRunProperties = void 0;
     };
     if (textSegments && textSegments.length > 0) {
       const uniformSegmentOverrides = computeUniformSegmentOverrides(textStyle, textSegments);
@@ -26742,8 +27598,16 @@ var PptxHandlerRuntime13 = class extends PptxHandlerRuntime12 {
         };
         const segmentText = String(segment.text ?? "");
         const lineParts = segmentText.split("\n");
-        if (currentRuns.length === 0 && segment.bulletInfo) {
-          currentBulletInfo = segment.bulletInfo;
+        if (currentRuns.length === 0) {
+          if (segment.bulletInfo) {
+            currentBulletInfo = segment.bulletInfo;
+          }
+          if (segment.paragraphLevel !== void 0) {
+            currentLevel = segment.paragraphLevel;
+          }
+          if (segment.endParaRunProperties) {
+            currentEndParaRunProperties = segment.endParaRunProperties;
+          }
         }
         lineParts.forEach((linePart, lineIndex) => {
           if (segment.rubyText !== void 0) {
@@ -26841,6 +27705,9 @@ var PptxHandlerRuntime14 = class extends PptxHandlerRuntime13 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeSaveShapeXml.ts
+var OLE_OBJECT_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/oleObject";
+var IMAGE_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+var OLE_GRAPHIC_DATA_URI = "http://schemas.openxmlformats.org/presentationml/2006/ole";
 var PptxHandlerRuntime15 = class _PptxHandlerRuntime extends PptxHandlerRuntime14 {
   /**
    * Build a `p:graphicFrame` XML skeleton for an SDK-created table.
@@ -26891,6 +27758,148 @@ var PptxHandlerRuntime15 = class _PptxHandlerRuntime extends PptxHandlerRuntime1
       }
     };
   }
+  /**
+   * Build a `p:graphicFrame` XML skeleton for an OLE object element.
+   *
+   * Used both for SDK-created OLE elements (no `rawXml`) and to refresh
+   * a few key attributes on a loaded element when the typed fields have
+   * been mutated. The output is the canonical
+   * `p:graphicFrame > a:graphic > a:graphicData uri="…/ole" > p:oleObj`
+   * shape per ECMA-376 §19.3.1.34 / §13.3.4.
+   *
+   * The caller (`processSlideElement`) is responsible for ensuring the
+   * embed / preview-image relationships referenced from `r:id` / `r:embed`
+   * exist in the slide's rels file. This method does not register them
+   * itself because the typed model does not currently carry the binary
+   * payload — the binary part must already be in the package (loaded from
+   * the original file). A fully-fabricated SDK OLE element therefore
+   * still requires the consumer to attach the binary out-of-band; this
+   * method simply emits a schema-valid envelope referencing the
+   * specified relationship ID.
+   */
+  createOleGraphicFrameXml(el, embedRelationshipId) {
+    const EMU = _PptxHandlerRuntime.EMU_PER_PX;
+    const offX = String(Math.round(el.x * EMU));
+    const offY = String(Math.round(el.y * EMU));
+    const extCx = String(Math.round(Math.max(el.width, 1) * EMU));
+    const extCy = String(Math.round(Math.max(el.height, 1) * EMU));
+    const oleObj = {
+      "@_showAsIcon": "0",
+      "@_imgW": extCx,
+      "@_imgH": extCy
+    };
+    if (el.oleProgId) {
+      oleObj["@_progId"] = el.oleProgId;
+    }
+    if (el.oleName) {
+      oleObj["@_name"] = el.oleName;
+    }
+    if (el.oleClsId) {
+      oleObj["@_classid"] = el.oleClsId;
+    }
+    if (embedRelationshipId) {
+      oleObj["@_r:id"] = embedRelationshipId;
+    }
+    if (el.isLinked) {
+      oleObj["p:link"] = {
+        "@_r:id": embedRelationshipId,
+        "@_updateAutomatic": "1"
+      };
+    } else {
+      oleObj["p:embed"] = {};
+    }
+    oleObj["p:pic"] = {
+      "p:nvPicPr": {
+        "p:cNvPr": { "@_id": "0", "@_name": el.oleName || "OleObject" },
+        "p:cNvPicPr": {},
+        "p:nvPr": {}
+      },
+      "p:blipFill": {
+        "a:blip": {},
+        "a:stretch": { "a:fillRect": {} }
+      },
+      "p:spPr": {
+        "a:xfrm": {
+          "a:off": { "@_x": offX, "@_y": offY },
+          "a:ext": { "@_cx": extCx, "@_cy": extCy }
+        },
+        "a:prstGeom": { "@_prst": "rect", "a:avLst": {} }
+      }
+    };
+    return {
+      "p:nvGraphicFramePr": {
+        "p:cNvPr": { "@_id": "0", "@_name": el.oleName || el.fileName || "OleObject" },
+        "p:cNvGraphicFramePr": {
+          "a:graphicFrameLocks": { "@_noChangeAspect": "1" }
+        },
+        "p:nvPr": {}
+      },
+      "p:xfrm": {
+        "a:off": { "@_x": offX, "@_y": offY },
+        "a:ext": { "@_cx": extCx, "@_cy": extCy }
+      },
+      "a:graphic": {
+        "a:graphicData": {
+          "@_uri": OLE_GRAPHIC_DATA_URI,
+          "p:oleObj": oleObj
+        }
+      }
+    };
+  }
+  /**
+   * Refresh editable typed-field attributes on a loaded OLE graphicFrame's
+   * raw XML. Only attributes that round-trip through the typed model
+   * (`progId`, `name`, `classid`) are touched so unknown extension data
+   * passes through verbatim.
+   */
+  applyOleTypedFieldUpdates(shape, el) {
+    const oleObj = shape["a:graphic"]?.["a:graphicData"]?.["p:oleObj"];
+    if (!oleObj) {
+      return;
+    }
+    if (el.oleProgId) {
+      oleObj["@_progId"] = el.oleProgId;
+    }
+    if (el.oleName !== void 0) {
+      if (el.oleName.length > 0) {
+        oleObj["@_name"] = el.oleName;
+      } else {
+        delete oleObj["@_name"];
+      }
+    }
+    if (el.oleClsId) {
+      oleObj["@_classid"] = el.oleClsId;
+    }
+  }
+  /** Look up the existing OLE binary relationship ID for this slide, if any. */
+  resolveOleEmbedRelationshipId(slideRelationships, oleTarget) {
+    if (!oleTarget) {
+      return void 0;
+    }
+    const normalisedTarget = oleTarget.replace(/^ppt\//, "../").replace(/^\/+/, "");
+    const lowerTarget = normalisedTarget.toLowerCase();
+    for (const rel of slideRelationships) {
+      const relType = String(rel?.["@_Type"] || "");
+      if (relType !== OLE_OBJECT_RELATIONSHIP_TYPE) {
+        continue;
+      }
+      const target = String(rel?.["@_Target"] || "").toLowerCase().trim();
+      if (target === lowerTarget || target.endsWith(lowerTarget) || lowerTarget.endsWith(target)) {
+        const relId = String(rel?.["@_Id"] || "").trim();
+        if (relId.length > 0) {
+          return relId;
+        }
+      }
+    }
+    const fallback = slideRelationships.find(
+      (rel) => String(rel?.["@_Type"] || "") === OLE_OBJECT_RELATIONSHIP_TYPE
+    );
+    const fallbackId = String(fallback?.["@_Id"] || "").trim();
+    return fallbackId.length > 0 ? fallbackId : void 0;
+  }
+  /** Constants are exposed so the element-writer mixin can reuse them. */
+  static OLE_OBJECT_RELATIONSHIP_TYPE = OLE_OBJECT_RELATIONSHIP_TYPE;
+  static OLE_IMAGE_RELATIONSHIP_TYPE = IMAGE_RELATIONSHIP_TYPE;
   /**
    * Build a p:sp XML object for an ink annotation element.
    * Each ink path becomes a separate a:path within a:pathLst,
@@ -27207,6 +28216,9 @@ var PptxHandlerRuntime16 = class extends PptxHandlerRuntime15 {
   buildOuterShadowXml(shapeStyle) {
     return this.colorStyleCodec.buildOuterShadowXml(shapeStyle);
   }
+  buildPresetShadowXml(shapeStyle) {
+    return this.colorStyleCodec.buildPresetShadowXml(shapeStyle);
+  }
   buildInnerShadowXml(shapeStyle) {
     return this.colorStyleCodec.buildInnerShadowXml(shapeStyle);
   }
@@ -27757,6 +28769,10 @@ var PptxHandlerRuntime19 = class _PptxHandlerRuntime extends PptxHandlerRuntime1
     const solidFill = runProperties["a:solidFill"];
     if (solidFill) {
       style.color = this.parseColor(solidFill);
+      const colorXml = extractColorChoiceXml(solidFill);
+      if (colorXml) {
+        style.colorXml = colorXml;
+      }
     }
     this.applyHyperlinkStyle(style, runProperties, relationshipMap);
     const capAttr = String(runProperties["@_cap"] || "").trim().toLowerCase();
@@ -27804,12 +28820,86 @@ var PptxHandlerRuntime19 = class _PptxHandlerRuntime extends PptxHandlerRuntime1
     if (bmk) {
       style.bookmark = bmk;
     }
+    const altLang = String(runProperties["@_altLang"] || "").trim();
+    if (altLang) {
+      style.altLanguage = altLang;
+    }
+    if (runProperties["@_smtId"] !== void 0) {
+      const smtIdRaw = Number.parseInt(String(runProperties["@_smtId"]), 10);
+      if (Number.isFinite(smtIdRaw)) {
+        style.smartTagId = smtIdRaw;
+      }
+    }
+    this.applyTextFontMetadata(style, latin, "latin");
+    this.applyTextFontMetadata(style, eastAsian, "eastAsia");
+    this.applyTextFontMetadata(style, complexScript, "complexScript");
+    this.applyTextFontMetadata(style, runProperties["a:sym"], "symbol");
     const runEffectList = runProperties["a:effectLst"];
     if (runEffectList) {
       this.applyTextRunEffects(style, runEffectList);
     }
     return style;
   }
+  /**
+   * Copy `@panose` / `@pitchFamily` / `@charset` from a font child node
+   * (`a:latin`, `a:ea`, `a:cs`, `a:sym`) onto the matching `*Font*`
+   * fields of `style`.
+   */
+  applyTextFontMetadata(style, fontNode, kind) {
+    if (!fontNode) {
+      return;
+    }
+    const panose = String(fontNode["@_panose"] || "").trim();
+    const pitchRaw = fontNode["@_pitchFamily"];
+    const charsetRaw = fontNode["@_charset"];
+    const pitch = pitchRaw !== void 0 && pitchRaw !== null ? Number.parseInt(String(pitchRaw), 10) : void 0;
+    const charset = charsetRaw !== void 0 && charsetRaw !== null ? Number.parseInt(String(charsetRaw), 10) : void 0;
+    if (kind === "latin") {
+      if (panose) {
+        style.latinFontPanose = panose;
+      }
+      if (typeof pitch === "number" && Number.isFinite(pitch)) {
+        style.latinFontPitchFamily = pitch;
+      }
+      if (typeof charset === "number" && Number.isFinite(charset)) {
+        style.latinFontCharset = charset;
+      }
+      return;
+    }
+    if (kind === "eastAsia") {
+      if (panose) {
+        style.eastAsiaFontPanose = panose;
+      }
+      if (typeof pitch === "number" && Number.isFinite(pitch)) {
+        style.eastAsiaFontPitchFamily = pitch;
+      }
+      if (typeof charset === "number" && Number.isFinite(charset)) {
+        style.eastAsiaFontCharset = charset;
+      }
+      return;
+    }
+    if (kind === "complexScript") {
+      if (panose) {
+        style.complexScriptFontPanose = panose;
+      }
+      if (typeof pitch === "number" && Number.isFinite(pitch)) {
+        style.complexScriptFontPitchFamily = pitch;
+      }
+      if (typeof charset === "number" && Number.isFinite(charset)) {
+        style.complexScriptFontCharset = charset;
+      }
+      return;
+    }
+    if (panose) {
+      style.symbolFontPanose = panose;
+    }
+    if (typeof pitch === "number" && Number.isFinite(pitch)) {
+      style.symbolFontPitchFamily = pitch;
+    }
+    if (typeof charset === "number" && Number.isFinite(charset)) {
+      style.symbolFontCharset = charset;
+    }
+  }
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeTextEditing.ts
@@ -28245,7 +29335,7 @@ var PptxHandlerRuntime21 = class extends PptxHandlerRuntime20 {
 };
 
 // src/core/core/runtime/table-cell-save-helpers.ts
-function writeCellFill(tcPr, style) {
+function writeCellFill(tcPr, style, resolveColorXml) {
   if (style.fillMode === "gradient" && style.gradientFillStops && style.gradientFillStops.length > 0) {
     delete tcPr["a:solidFill"];
     delete tcPr["a:pattFill"];
@@ -28324,11 +29414,12 @@ function writeCellFill(tcPr, style) {
   } else if (style.backgroundColor) {
     delete tcPr["a:gradFill"];
     delete tcPr["a:pattFill"];
-    tcPr["a:solidFill"] = {
-      "a:srgbClr": {
-        "@_val": style.backgroundColor.replace("#", "")
-      }
-    };
+    const resolvedOriginal = style.backgroundColorXml && resolveColorXml ? resolveColorXml(style.backgroundColorXml) : void 0;
+    tcPr["a:solidFill"] = serializeColorChoice(
+      style.backgroundColorXml,
+      resolvedOriginal,
+      style.backgroundColor
+    );
   }
 }
 function writeDiagonalBorders(tcPr, style, emuPerPx) {
@@ -28459,7 +29550,7 @@ var PptxHandlerRuntime22 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
       xmlCell["a:tcPr"] = {};
     }
     const tcPr = xmlCell["a:tcPr"];
-    writeCellFill(tcPr, style);
+    writeCellFill(tcPr, style, (colorXml) => this.parseColor(colorXml));
     if (style.vAlign) {
       const vAlignMap = {
         top: "t",
@@ -28541,35 +29632,29 @@ var PptxHandlerRuntime22 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
         }
       }
     }
-    if (style.marginLeft !== void 0 || style.marginRight !== void 0 || style.marginTop !== void 0 || style.marginBottom !== void 0) {
-      const emuPerPx = _PptxHandlerRuntime.EMU_PER_PX;
-      if (!tcPr["a:tcMar"]) {
-        tcPr["a:tcMar"] = {};
-      }
-      const tcMar = tcPr["a:tcMar"];
-      if (style.marginLeft !== void 0) {
-        tcMar["a:marL"] = {
-          "@_w": String(Math.round(style.marginLeft * emuPerPx))
-        };
-      }
-      if (style.marginRight !== void 0) {
-        tcMar["a:marR"] = {
-          "@_w": String(Math.round(style.marginRight * emuPerPx))
-        };
-      }
-      if (style.marginTop !== void 0) {
-        tcMar["a:marT"] = {
-          "@_w": String(Math.round(style.marginTop * emuPerPx))
-        };
-      }
-      if (style.marginBottom !== void 0) {
-        tcMar["a:marB"] = {
-          "@_w": String(Math.round(style.marginBottom * emuPerPx))
-        };
-      }
+    const emuPerPx = _PptxHandlerRuntime.EMU_PER_PX;
+    if (style.marginLeft !== void 0) {
+      tcPr["@_marL"] = String(Math.round(style.marginLeft * emuPerPx));
     }
+    if (style.marginRight !== void 0) {
+      tcPr["@_marR"] = String(Math.round(style.marginRight * emuPerPx));
+    }
+    if (style.marginTop !== void 0) {
+      tcPr["@_marT"] = String(Math.round(style.marginTop * emuPerPx));
+    }
+    if (style.marginBottom !== void 0) {
+      tcPr["@_marB"] = String(Math.round(style.marginBottom * emuPerPx));
+    }
+    delete tcPr["a:tcMar"];
     writeDiagonalBorders(tcPr, style, _PptxHandlerRuntime.EMU_PER_PX);
     writeCellTextFormatting(xmlCell, style, this.ensureArray.bind(this));
+    const reordered = reorderObjectKeys(tcPr, TC_PR_BORDERS_ORDER);
+    for (const key of Object.keys(tcPr)) {
+      delete tcPr[key];
+    }
+    for (const key of Object.keys(reordered)) {
+      tcPr[key] = reordered[key];
+    }
   }
 };
 
@@ -28673,6 +29758,49 @@ function createDefaultXmlCell() {
 // src/core/core/runtime/table-xml-rebuild.ts
 var GRID_COL_ID_EXT_URI = "{9D8B030D-6E8A-4147-A177-3AD203B41FA5}";
 var A16_NAMESPACE = "http://schemas.microsoft.com/office/drawing/2014/main";
+function ensureA16NamespaceOnSlideRoot(slideRoot) {
+  if (!slideRoot["@_xmlns:a16"]) {
+    slideRoot["@_xmlns:a16"] = A16_NAMESPACE;
+  }
+  if (!slideRoot["@_xmlns:mc"]) {
+    slideRoot["@_xmlns:mc"] = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+  }
+  const existingIgnorable = String(slideRoot["@_mc:Ignorable"] || "").trim();
+  if (existingIgnorable.length === 0) {
+    slideRoot["@_mc:Ignorable"] = "a16";
+    return;
+  }
+  const tokens = existingIgnorable.split(/\s+/).filter((token) => token.length > 0);
+  if (!tokens.includes("a16")) {
+    tokens.push("a16");
+    slideRoot["@_mc:Ignorable"] = tokens.join(" ");
+  }
+}
+function slideContainsA16Element(node) {
+  if (node === null || node === void 0) {
+    return false;
+  }
+  if (Array.isArray(node)) {
+    for (const entry of node) {
+      if (slideContainsA16Element(entry)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  if (typeof node !== "object") {
+    return false;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (key.startsWith("a16:")) {
+      return true;
+    }
+    if (slideContainsA16Element(value)) {
+      return true;
+    }
+  }
+  return false;
+}
 function randomColumnId() {
   return String(Math.floor(Math.random() * 4294967295));
 }
@@ -28703,8 +29831,10 @@ function rebuildTableXmlFromData(tbl, tableData, emuPerPx, ensureArrayFn) {
     "a:extLst": {
       "a:ext": {
         "@_uri": GRID_COL_ID_EXT_URI,
+        // `xmlns:a16` is declared on the slide root by
+        // `ensureA16NamespaceOnSlideRoot`; emitting it here too is
+        // schema-redundant and PowerPoint flags it.
         "a16:colId": {
-          "@_xmlns:a16": A16_NAMESPACE,
           "@_val": existingColIds[i] || randomColumnId()
         }
       }
@@ -29063,26 +30193,64 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
                 continue;
               }
               const scalingNode = this.xmlLookupService.getChildByLocalName(axisNode, "scaling");
-              if (!scalingNode) {
-                continue;
+              if (scalingNode) {
+                if (matchingAxis.logBase !== void 0 && matchingAxis.logBase > 0) {
+                  const logBaseKey = Object.keys(scalingNode).find(
+                    (k) => this.compatibilityService.getXmlLocalName(k) === "logBase"
+                  );
+                  if (logBaseKey) {
+                    scalingNode[logBaseKey]["@_val"] = String(matchingAxis.logBase);
+                  } else {
+                    scalingNode["c:logBase"] = {
+                      "@_val": String(matchingAxis.logBase)
+                    };
+                  }
+                } else if (matchingAxis.logScale === false) {
+                  const logBaseKey = Object.keys(scalingNode).find(
+                    (k) => this.compatibilityService.getXmlLocalName(k) === "logBase"
+                  );
+                  if (logBaseKey) {
+                    delete scalingNode[logBaseKey];
+                  }
+                }
+                this.upsertChartAxisChild(
+                  scalingNode,
+                  "min",
+                  matchingAxis.min !== void 0 ? String(matchingAxis.min) : void 0
+                );
+                this.upsertChartAxisChild(
+                  scalingNode,
+                  "max",
+                  matchingAxis.max !== void 0 ? String(matchingAxis.max) : void 0
+                );
               }
-              if (matchingAxis.logBase !== void 0 && matchingAxis.logBase > 0) {
-                const logBaseKey = Object.keys(scalingNode).find(
-                  (k) => this.compatibilityService.getXmlLocalName(k) === "logBase"
+              if (matchingAxis.numFmt) {
+                const numFmtKey = Object.keys(axisNode).find(
+                  (k) => this.compatibilityService.getXmlLocalName(k) === "numFmt"
                 );
-                if (logBaseKey) {
-                  scalingNode[logBaseKey]["@_val"] = String(matchingAxis.logBase);
+                const numFmtAttrs = {
+                  "@_formatCode": matchingAxis.numFmt.formatCode,
+                  "@_sourceLinked": matchingAxis.numFmt.sourceLinked ? "1" : "0"
+                };
+                if (numFmtKey) {
+                  axisNode[numFmtKey] = numFmtAttrs;
                 } else {
-                  scalingNode["c:logBase"] = {
-                    "@_val": String(matchingAxis.logBase)
-                  };
+                  axisNode["c:numFmt"] = numFmtAttrs;
                 }
-              } else if (matchingAxis.logScale === false) {
-                const logBaseKey = Object.keys(scalingNode).find(
-                  (k) => this.compatibilityService.getXmlLocalName(k) === "logBase"
+              }
+              this.upsertChartAxisChild(
+                axisNode,
+                "majorUnit",
+                matchingAxis.majorUnit !== void 0 ? String(matchingAxis.majorUnit) : void 0
+              );
+              if (matchingAxis.tickLblPos !== void 0) {
+                const tickLblKey = Object.keys(axisNode).find(
+                  (k) => this.compatibilityService.getXmlLocalName(k) === "tickLblPos"
                 );
-                if (logBaseKey) {
-                  delete scalingNode[logBaseKey];
+                if (tickLblKey) {
+                  axisNode[tickLblKey]["@_val"] = matchingAxis.tickLblPos;
+                } else {
+                  axisNode["c:tickLblPos"] = { "@_val": matchingAxis.tickLblPos };
                 }
               }
             }
@@ -29095,6 +30263,18 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
     }
     this.pendingChartUpdates = void 0;
   }
+  /**
+   * Upsert a `c:<localName>` child with `@_val` on an axis or scaling node.
+   * When `value` is undefined, removes any existing child of that local name.
+   */
+  upsertChartAxisChild(parent, localName, value) {
+    upsertChartAxisChild(
+      parent,
+      localName,
+      value,
+      (key) => this.compatibilityService.getXmlLocalName(key)
+    );
+  }
   /**
    * Update the cached point values in a chart reference node
    * (numRef/strRef or numLit/strLit).
@@ -30374,17 +31554,13 @@ var PptxHandlerRuntime28 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
         delete spPr["a:noFill"];
         delete spPr["a:gradFill"];
         delete spPr["a:blipFill"];
-        const solidFill = {
-          "a:srgbClr": {
-            "@_val": fillColor.replace("#", "")
-          }
-        };
-        if (typeof shapeStyle.fillOpacity === "number" && shapeStyle.fillOpacity >= 0 && shapeStyle.fillOpacity < 1) {
-          solidFill["a:srgbClr"]["a:alpha"] = {
-            "@_val": String(Math.round(this.clampUnitInterval(shapeStyle.fillOpacity) * 1e5))
-          };
-        }
-        spPr["a:solidFill"] = solidFill;
+        const resolvedOriginal = shapeStyle.fillColorXml ? this.parseColor(shapeStyle.fillColorXml) : void 0;
+        spPr["a:solidFill"] = serializeColorChoice(
+          shapeStyle.fillColorXml,
+          resolvedOriginal,
+          fillColor,
+          shapeStyle.fillOpacity
+        );
       }
     }
     if (shapeStyle.strokeColor !== void 0) {
@@ -30399,17 +31575,13 @@ var PptxHandlerRuntime28 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
         delete lineNode["a:solidFill"];
       } else {
         delete lineNode["a:noFill"];
-        const lineFill = {
-          "a:srgbClr": {
-            "@_val": shapeStyle.strokeColor.replace("#", "")
-          }
-        };
-        if (typeof shapeStyle.strokeOpacity === "number" && shapeStyle.strokeOpacity >= 0 && shapeStyle.strokeOpacity < 1) {
-          lineFill["a:srgbClr"]["a:alpha"] = {
-            "@_val": String(Math.round(this.clampUnitInterval(shapeStyle.strokeOpacity) * 1e5))
-          };
-        }
-        lineNode["a:solidFill"] = lineFill;
+        const resolvedStrokeOriginal = shapeStyle.strokeColorXml ? this.parseColor(shapeStyle.strokeColorXml) : void 0;
+        lineNode["a:solidFill"] = serializeColorChoice(
+          shapeStyle.strokeColorXml,
+          resolvedStrokeOriginal,
+          shapeStyle.strokeColor,
+          shapeStyle.strokeOpacity
+        );
       }
     }
     if (shapeStyle.strokeDash !== void 0) {
@@ -30490,7 +31662,11 @@ var PptxHandlerRuntime28 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
       } else if (shapeStyle.lineJoin === "bevel") {
         lineNode["a:bevel"] = {};
       } else if (shapeStyle.lineJoin === "miter") {
-        lineNode["a:miter"] = { "@_lim": "800000" };
+        const miterNode = {};
+        if (typeof shapeStyle.miterLimit === "number" && Number.isFinite(shapeStyle.miterLimit) && shapeStyle.miterLimit !== 8e5) {
+          miterNode["@_lim"] = String(Math.round(shapeStyle.miterLimit));
+        }
+        lineNode["a:miter"] = miterNode;
       }
     }
     if (shapeStyle.lineCap !== void 0) {
@@ -30510,6 +31686,82 @@ var PptxHandlerRuntime28 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
       spPr["a:ln"]["a:effectLst"] = lineEffectListXml;
     }
   }
+  /**
+   * Serialize the shape's `<p:style>` block (CT_ShapeStyle §20.1.2.2.36)
+   * from the persisted ref indices/colour XML. Emits children in spec
+   * order: `lnRef → fillRef → effectRef → fontRef`.
+   *
+   * When the original shape XML already contained a `<p:style>` we mutate
+   * that node in place so any unmodelled attributes/children are preserved.
+   * When it didn't, we create one. When the shape no longer has any ref
+   * data we leave the existing `<p:style>` (if any) untouched — silently
+   * dropping it would break round-tripping.
+   *
+   * Phase 2 Stream B / C-H2.
+   */
+  applyShapeStyleRefs(shape, shapeStyle) {
+    const hasAnyRef = shapeStyle.lnRefIdx !== void 0 || shapeStyle.fillRefIdx !== void 0 || shapeStyle.effectRefIdx !== void 0 || shapeStyle.fontRefIdx !== void 0;
+    if (!hasAnyRef) {
+      return;
+    }
+    const existing = shape["p:style"];
+    const styleNode = existing ?? {};
+    if (shapeStyle.lnRefIdx !== void 0) {
+      const lnRef = styleNode["a:lnRef"] ?? {};
+      lnRef["@_idx"] = String(shapeStyle.lnRefIdx);
+      this.replaceRefColorChoice(lnRef, shapeStyle.lnRefColorXml);
+      styleNode["a:lnRef"] = lnRef;
+    }
+    if (shapeStyle.fillRefIdx !== void 0) {
+      const fillRef = styleNode["a:fillRef"] ?? {};
+      fillRef["@_idx"] = String(shapeStyle.fillRefIdx);
+      this.replaceRefColorChoice(fillRef, shapeStyle.fillRefColorXml);
+      styleNode["a:fillRef"] = fillRef;
+    }
+    if (shapeStyle.effectRefIdx !== void 0) {
+      const effectRef = styleNode["a:effectRef"] ?? {};
+      effectRef["@_idx"] = String(shapeStyle.effectRefIdx);
+      this.replaceRefColorChoice(effectRef, shapeStyle.effectRefColorXml);
+      styleNode["a:effectRef"] = effectRef;
+    }
+    if (shapeStyle.fontRefIdx !== void 0) {
+      const fontRef = styleNode["a:fontRef"] ?? {};
+      fontRef["@_idx"] = shapeStyle.fontRefIdx;
+      this.replaceRefColorChoice(fontRef, shapeStyle.fontRefColorXml);
+      styleNode["a:fontRef"] = fontRef;
+    }
+    const reordered = reorderObjectKeys(styleNode, SHAPE_STYLE_ORDER);
+    for (const key of Object.keys(styleNode)) {
+      delete styleNode[key];
+    }
+    for (const key of Object.keys(reordered)) {
+      styleNode[key] = reordered[key];
+    }
+    shape["p:style"] = styleNode;
+  }
+  /**
+   * Replace any existing colour-choice child on a style-matrix-reference
+   * element with the given preserved XML, or strip all colour children
+   * when the override is undefined.
+   */
+  replaceRefColorChoice(refNode, colorXml) {
+    for (const key of [
+      "a:scrgbClr",
+      "a:srgbClr",
+      "a:hslClr",
+      "a:sysClr",
+      "a:schemeClr",
+      "a:prstClr"
+    ]) {
+      delete refNode[key];
+    }
+    if (!colorXml) {
+      return;
+    }
+    for (const [key, value] of Object.entries(colorXml)) {
+      refNode[key] = value;
+    }
+  }
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeSaveEffectsWriter.ts
@@ -30519,17 +31771,22 @@ var PptxHandlerRuntime29 = class extends PptxHandlerRuntime28 {
    * effectDag, 3D scene, and 3D shape properties to the given spPr XML object.
    */
   applyEffectsAndThreeD(spPr, shapeStyle) {
-    const outerShadowXml = this.buildOuterShadowXml(shapeStyle);
+    const presetShadowXml = shapeStyle.presetShadowName ? this.buildPresetShadowXml(shapeStyle) : void 0;
+    const outerShadowXml = presetShadowXml ? void 0 : this.buildOuterShadowXml(shapeStyle);
     const innerShadowXml = this.buildInnerShadowXml(shapeStyle);
     const glowXml = this.buildGlowXml(shapeStyle);
     const softEdgeXml = this.buildSoftEdgeXml(shapeStyle);
     const reflectionXml = this.buildReflectionXml(shapeStyle);
     const blurXml = this.buildBlurXml(shapeStyle);
-    const hasAnyEffect = outerShadowXml || innerShadowXml || glowXml || softEdgeXml || reflectionXml || blurXml;
+    const hasAnyEffect = outerShadowXml || presetShadowXml || innerShadowXml || glowXml || softEdgeXml || reflectionXml || blurXml;
     if (hasAnyEffect) {
       const effectList = spPr["a:effectLst"] || {};
-      if (outerShadowXml) {
+      if (presetShadowXml) {
+        effectList["a:prstShdw"] = presetShadowXml;
+        delete effectList["a:outerShdw"];
+      } else if (outerShadowXml) {
         effectList["a:outerShdw"] = outerShadowXml;
+        delete effectList["a:prstShdw"];
       }
       if (innerShadowXml) {
         effectList["a:innerShdw"] = innerShadowXml;
@@ -30546,12 +31803,13 @@ var PptxHandlerRuntime29 = class extends PptxHandlerRuntime28 {
       if (blurXml) {
         effectList["a:blur"] = blurXml;
       }
-      spPr["a:effectLst"] = effectList;
+      spPr["a:effectLst"] = reorderObjectKeys(effectList, EFFECT_LST_ORDER);
     } else {
       const effectList = spPr["a:effectLst"];
       if (effectList) {
-        if (shapeStyle.shadowColor !== void 0 && !outerShadowXml) {
+        if (shapeStyle.shadowColor !== void 0 && !outerShadowXml && !presetShadowXml) {
           delete effectList["a:outerShdw"];
+          delete effectList["a:prstShdw"];
         }
         if (shapeStyle.innerShadowColor !== void 0 && !innerShadowXml) {
           delete effectList["a:innerShdw"];
@@ -30570,6 +31828,8 @@ var PptxHandlerRuntime29 = class extends PptxHandlerRuntime28 {
         }
         if (Object.keys(effectList).length === 0) {
           delete spPr["a:effectLst"];
+        } else {
+          spPr["a:effectLst"] = reorderObjectKeys(effectList, EFFECT_LST_ORDER);
         }
       }
     }
@@ -30730,7 +31990,8 @@ var PptxHandlerRuntime30 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
       );
     }
     if (el.textStyle?.hOverflow) {
-      bodyPr["@_hOverflow"] = el.textStyle.hOverflow;
+      bodyPr["@_horzOverflow"] = el.textStyle.hOverflow;
+      delete bodyPr["@_hOverflow"];
     }
     if (el.textStyle?.vertOverflow) {
       bodyPr["@_vertOverflow"] = el.textStyle.vertOverflow;
@@ -30961,7 +32222,10 @@ var PptxHandlerRuntime31 = class extends PptxHandlerRuntime30 {
     const elWithPaths = el;
     if (elWithPaths.customGeometryPaths && elWithPaths.customGeometryPaths.length > 0) {
       delete spPr["a:prstGeom"];
-      spPr["a:custGeom"] = customGeometryPathsToXml(elWithPaths.customGeometryPaths);
+      spPr["a:custGeom"] = customGeometryPathsToXml(
+        elWithPaths.customGeometryPaths,
+        elWithPaths.customGeometryRawData
+      );
     } else if (spPr["a:prstGeom"]) {
       const presetGeometry = el.type === "connector" ? this.normalizePresetGeometry(el.shapeType || "straightConnector1") : this.normalizePresetGeometry(el.shapeType);
       const prstGeom = spPr["a:prstGeom"];
@@ -31086,6 +32350,42 @@ var PptxHandlerRuntime32 = class _PptxHandlerRuntime extends PptxHandlerRuntime3
   isGraphicFrameShape(shape) {
     return Boolean(shape["p:nvGraphicFramePr"] || shape["a:graphic"] && shape["p:xfrm"]);
   }
+  /**
+   * Reorder children of `p:spPr` to match CT_ShapeProperties (§20.1.2.2.35).
+   * Also reorders any nested `a:blipFill` per CT_BlipFillProperties.
+   * fast-xml-parser preserves insertion order; PowerPoint validates against
+   * the schema's required order, so save-side mutations must be re-sorted.
+   */
+  finalizeSpPrSchemaOrder(shape) {
+    const spPr = shape["p:spPr"];
+    if (!spPr) {
+      return;
+    }
+    const blipFill = spPr["a:blipFill"];
+    if (blipFill) {
+      this.reorderInPlace(blipFill, BLIP_FILL_ORDER);
+    }
+    this.reorderInPlace(spPr, SP_PR_ORDER);
+  }
+  /**
+   * Reorder children of the picture-level `p:blipFill` (CT_BlipFillProperties).
+   * Picture elements carry their blip data on the `p:pic` root, not under spPr.
+   */
+  finalizePictureBlipFillOrder(shape) {
+    const pBlipFill = shape["p:blipFill"];
+    if (pBlipFill) {
+      this.reorderInPlace(pBlipFill, BLIP_FILL_ORDER);
+    }
+  }
+  reorderInPlace(target, schemaOrder) {
+    const reordered = reorderObjectKeys(target, schemaOrder);
+    for (const key of Object.keys(target)) {
+      delete target[key];
+    }
+    for (const key of Object.keys(reordered)) {
+      target[key] = reordered[key];
+    }
+  }
   /** Whether an element ID indicates a template (layout/master) element. */
   isTemplateElementId(elementId) {
     return elementId.startsWith("layout-") || elementId.startsWith("master-");
@@ -31109,18 +32409,51 @@ var PptxHandlerRuntime32 = class _PptxHandlerRuntime extends PptxHandlerRuntime3
       }
       return;
     }
+    if (el.type === "contentPart") {
+      if (shape) {
+        this.elementTransformUpdater.applyTransform(shape, el, _PptxHandlerRuntime.EMU_PER_PX);
+        collectors.contentParts.push(shape);
+      } else {
+        this.compatibilityService.reportWarning({
+          code: "SAVE_ELEMENT_SKIPPED",
+          message: `Content part '${el.id}' has no rawXml and was skipped during save.`,
+          scope: "save",
+          slideId: ctx.slide.id,
+          elementId: el.id
+        });
+      }
+      return;
+    }
     if (!shape && (el.type === "text" || el.type === "shape")) {
       shape = this.createElementXml(el);
     }
     if (!shape && el.type === "connector") {
       shape = this.createConnectorXml(el);
     }
-    if (!shape && el.type === "ink") {
-      shape = this.createInkShapeXml(el);
+    if (el.type === "ink") {
+      if (!shape) {
+        shape = this.createInkShapeXml(el);
+        this.compatibilityService.reportWarning({
+          code: "SAVE_INK_ENCODED_AS_CUSTGEOM",
+          message: "SDK-created ink element serialized as custGeom shape; pressure/tool metadata not represented in OOXML aink format.",
+          scope: "save",
+          slideId: ctx.slide.id,
+          elementId: el.id
+        });
+      }
     }
     if (!shape && el.type === "table") {
       shape = this.createTableGraphicFrameXml(el);
     }
+    if (el.type === "ole") {
+      const oleEl = el;
+      if (shape) {
+        this.applyOleTypedFieldUpdates(shape, oleEl);
+      } else {
+        const embedRid = this.resolveOleEmbedRelationshipId(ctx.slideRelationships, oleEl.oleTarget) || ctx.slideRelationshipRegistry.nextRelationshipId();
+        shape = this.createOleGraphicFrameXml(oleEl, embedRid);
+      }
+    }
     if (!shape) {
       this.compatibilityService.reportWarning({
         code: "SAVE_ELEMENT_SKIPPED",
@@ -31133,11 +32466,14 @@ var PptxHandlerRuntime32 = class _PptxHandlerRuntime extends PptxHandlerRuntime3
     }
     this.elementTransformUpdater.applyTransform(shape, el, _PptxHandlerRuntime.EMU_PER_PX);
     this.applyImageProperties(shape, el);
+    this.finalizePictureBlipFillOrder(shape);
     this.applyGeometryUpdate(shape, el);
     if (hasShapeProperties(el) && el.shapeStyle && shape["p:spPr"]) {
       const spPr = shape["p:spPr"];
       this.applyFillAndStroke(spPr, el.shapeStyle);
       this.applyEffectsAndThreeD(spPr, el.shapeStyle);
+      this.finalizeSpPrSchemaOrder(shape);
+      this.applyShapeStyleRefs(shape, el.shapeStyle);
     }
     if (hasTextProperties(el)) {
       this.applyTextBodyContent(
@@ -31295,7 +32631,8 @@ var PptxHandlerRuntime33 = class extends PptxHandlerRuntime32 {
       connectors: [],
       graphicFrames: [],
       groups: [],
-      model3ds: []
+      model3ds: [],
+      contentParts: []
     };
     const ctx = {
       slide,
@@ -31327,6 +32664,12 @@ var PptxHandlerRuntime33 = class extends PptxHandlerRuntime32 {
     } else {
       delete spTree["p16:model3D"];
     }
+    if (collectors.contentParts.length > 0) {
+      spTree["p:contentPart"] = collectors.contentParts;
+    } else {
+      delete spTree["p:contentPart"];
+    }
+    this.reapplyAlternateContentEnvelopes(spTree, collectors);
     const reassigned = shapeIdValidator.validateAndDeduplicateIds(
       spTree,
       (v) => this.ensureArray(v)
@@ -31344,12 +32687,426 @@ var PptxHandlerRuntime33 = class extends PptxHandlerRuntime32 {
     this.zip.file(slideRelsPath, this.builder.build(slideRelsData));
     this.applySlideDrawingGuides(slideNode, slide);
     this.deduplicateExtensionLists(xmlObj);
+    if (slideContainsA16Element(slideNode)) {
+      ensureA16NamespaceOnSlideRoot(slideNode);
+    }
     this.zip.file(slide.id, this.builder.build(xmlObj));
   }
+  /**
+   * Re-wrap selected children with their original `<mc:AlternateContent>`
+   * envelope (CC-4).
+   *
+   * Parsing merged the selected branch (Choice when supported, otherwise
+   * Fallback) into the spTree's tag arrays.  Without re-wrapping, dirty
+   * save would emit flat `<p:sp>`/`<p:pic>` etc. and drop the
+   * `<mc:Fallback>` branch — losing legacy rendering for files originally
+   * authored with newer-namespace features.
+   *
+   * Strategy: for each XmlObject in `collectors.*` that traces back to a
+   * known AC block, group by block and:
+   *   1. Remove the node from its flat collector / spTree array.
+   *   2. Clone the original AC envelope.
+   *   3. Replace the selected branch's `<{tag}>` children with the
+   *      live (possibly edited) nodes from the collectors.
+   *   4. Leave the unselected branch verbatim.
+   *
+   * Final envelopes are appended to `spTree['mc:AlternateContent']`.
+   */
+  reapplyAlternateContentEnvelopes(spTree, collectors) {
+    const TAG_TO_COLLECTOR = {
+      "p:sp": collectors.shapes,
+      "p:pic": collectors.pics,
+      "p:cxnSp": collectors.connectors,
+      "p:graphicFrame": collectors.graphicFrames,
+      "p:grpSp": collectors.groups,
+      "p:contentPart": collectors.contentParts,
+      // `model3d` does not flow through SHAPE_TREE_ELEMENT_TAGS, but the
+      // AC pathway in OpenXML decks frequently uses Choice = p16:model3D
+      // + Fallback = p:pic, so map it for completeness.
+      "p16:model3D": collectors.model3ds
+    };
+    const blockGroups = /* @__PURE__ */ new Map();
+    for (const tag of Object.keys(TAG_TO_COLLECTOR)) {
+      const collector = TAG_TO_COLLECTOR[tag];
+      if (!collector) {
+        continue;
+      }
+      for (const node of collector) {
+        const block = this.alternateContentBlockByRawXml.get(node);
+        if (!block) {
+          continue;
+        }
+        let entries = blockGroups.get(block);
+        if (!entries) {
+          entries = [];
+          blockGroups.set(block, entries);
+        }
+        entries.push({ tag, node, collector });
+      }
+    }
+    if (blockGroups.size === 0) {
+      return;
+    }
+    const envelopes = [];
+    for (const [block, entries] of blockGroups) {
+      for (const entry of entries) {
+        const idx = entry.collector.indexOf(entry.node);
+        if (idx !== -1) {
+          entry.collector.splice(idx, 1);
+        }
+      }
+      const clonedAc = { ...block.rawAc };
+      const liveByTag = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        let arr = liveByTag.get(entry.tag);
+        if (!arr) {
+          arr = [];
+          liveByTag.set(entry.tag, arr);
+        }
+        arr.push(entry.node);
+      }
+      if (block.selectedBranch === "choice") {
+        const choices = this.ensureArray(clonedAc["mc:Choice"]);
+        const targetIdx = block.choiceIndex ?? 0;
+        const original = choices[targetIdx];
+        if (original) {
+          const rebuilt = { ...original };
+          for (const tag of SHAPE_TREE_ELEMENT_TAGS) {
+            delete rebuilt[tag];
+          }
+          for (const [tag, nodes] of liveByTag) {
+            rebuilt[tag] = nodes.length === 1 ? nodes[0] : nodes;
+          }
+          choices[targetIdx] = rebuilt;
+          clonedAc["mc:Choice"] = choices.length === 1 ? choices[0] : choices;
+        }
+      } else {
+        const fallback = clonedAc["mc:Fallback"];
+        if (fallback) {
+          const rebuilt = { ...fallback };
+          for (const tag of SHAPE_TREE_ELEMENT_TAGS) {
+            delete rebuilt[tag];
+          }
+          for (const [tag, nodes] of liveByTag) {
+            rebuilt[tag] = nodes.length === 1 ? nodes[0] : nodes;
+          }
+          clonedAc["mc:Fallback"] = rebuilt;
+        }
+      }
+      envelopes.push(clonedAc);
+    }
+    spTree["p:sp"] = collectors.shapes;
+    spTree["p:pic"] = collectors.pics;
+    spTree["p:cxnSp"] = collectors.connectors;
+    spTree["p:graphicFrame"] = collectors.graphicFrames;
+    if (collectors.groups.length > 0) {
+      spTree["p:grpSp"] = collectors.groups;
+    } else {
+      delete spTree["p:grpSp"];
+    }
+    if (collectors.contentParts.length > 0) {
+      spTree["p:contentPart"] = collectors.contentParts;
+    } else {
+      delete spTree["p:contentPart"];
+    }
+    if (collectors.model3ds.length > 0) {
+      spTree["p16:model3D"] = collectors.model3ds;
+    } else {
+      delete spTree["p16:model3D"];
+    }
+    spTree["mc:AlternateContent"] = envelopes.length === 1 ? envelopes[0] : envelopes;
+  }
+};
+
+// src/core/core/runtime/PptxHandlerRuntimeSaveTheme.ts
+var PptxHandlerRuntime34 = class extends PptxHandlerRuntime33 {
+  /**
+   * Mark a theme path as dirty so the save pipeline will regenerate
+   * the theme XML from in-memory state. Optional — without this the
+   * original XML is preserved verbatim on save (C-H3).
+   */
+  markThemeDirty(themePath) {
+    this.dirtyThemePaths.add(themePath);
+  }
+  /**
+   * Mark all known theme paths dirty in one call.
+   */
+  markAllThemesDirty() {
+    for (const themePath of this.originalThemeXmlByPath.keys()) {
+      this.dirtyThemePaths.add(themePath);
+    }
+    for (const themePath of this.masterThemePaths.values()) {
+      this.dirtyThemePaths.add(themePath);
+    }
+  }
+  /**
+   * Persist all theme parts during save. Called from the save pipeline
+   * after master / layout XML have been flushed and before
+   * presentation.xml is serialized.
+   *
+   * Order of operations per theme path:
+   *
+   * 1. If the path is *not* in {@link dirtyThemePaths}, the existing
+   *    ZIP entry is already correct — no-op. (Original XML was placed
+   *    into the ZIP at load time.)
+   * 2. If the path is dirty, build a fresh `<a:theme>` document from
+   *    in-memory state and the captured raw subtrees, then overwrite
+   *    the ZIP entry.
+   */
+  async persistThemeParts() {
+    const seenThemePaths = /* @__PURE__ */ new Set();
+    for (const [masterPath, themePath] of this.masterThemePaths.entries()) {
+      if (!themePath) {
+        continue;
+      }
+      seenThemePaths.add(themePath);
+      if (!this.dirtyThemePaths.has(themePath)) {
+        continue;
+      }
+      const themeXml2 = this.buildThemeXml(themePath, masterPath);
+      if (themeXml2) {
+        this.zip.file(themePath, themeXml2);
+      }
+    }
+    for (const [themePath] of this.originalThemeXmlByPath.entries()) {
+      if (seenThemePaths.has(themePath)) {
+        continue;
+      }
+      if (!this.dirtyThemePaths.has(themePath)) {
+        continue;
+      }
+      const themeXml2 = this.buildThemeXml(themePath, void 0);
+      if (themeXml2) {
+        this.zip.file(themePath, themeXml2);
+      }
+    }
+  }
+  /**
+   * Build a complete `<a:theme>` XML document from in-memory state.
+   * Returns the serialized XML string (with XML prolog), or `undefined`
+   * if there is no source data to emit.
+   *
+   * - Color scheme: built from per-master color map (or global fallback).
+   * - Font scheme: built from per-master font map + per-script entries.
+   * - Format scheme: re-emit the original XML subtree if available; else
+   *   build a minimal scheme from {@link themeFormatScheme}.
+   * - objectDefaults / extraClrSchemeLst / custClrLst / extLst: re-emit
+   *   captured raw subtrees.
+   */
+  buildThemeXml(themePath, masterPath) {
+    const colorMap = masterPath && this.masterThemeColorMaps.get(masterPath) || this.globalThemeColorMapSnapshot || this.themeColorMap;
+    const fontMap = masterPath && this.masterThemeFontMaps.get(masterPath) || this.globalThemeFontMapSnapshot || this.themeFontMap;
+    const themeName = this.masterThemeNames.get(themePath) || "Office Theme";
+    const colorSchemeName = this.masterThemeColorSchemeNames.get(themePath) || themeName;
+    const fontSchemeName = this.masterThemeFontSchemeNames.get(themePath) || themeName;
+    const majorScripts = this.masterThemeMajorFontScripts.get(themePath) || {};
+    const minorScripts = this.masterThemeMinorFontScripts.get(themePath) || {};
+    const clrScheme = this.buildClrSchemeObject(colorSchemeName, colorMap);
+    const fontScheme = this.buildFontSchemeObject(
+      fontSchemeName,
+      fontMap,
+      majorScripts,
+      minorScripts
+    );
+    const fmtScheme = this.extractRawSubtreeFromOriginal(themePath, [
+      "a:theme",
+      "a:themeElements",
+      "a:fmtScheme"
+    ]);
+    const themeElements = {
+      "a:clrScheme": clrScheme,
+      "a:fontScheme": fontScheme
+    };
+    if (fmtScheme !== void 0) {
+      themeElements["a:fmtScheme"] = fmtScheme;
+    } else {
+      themeElements["a:fmtScheme"] = this.buildMinimalFmtScheme(themeName);
+    }
+    const themeRoot = {
+      "@_xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main",
+      "@_name": themeName,
+      "a:themeElements": themeElements
+    };
+    const objectDefaults = this.masterThemeObjectDefaults.get(themePath);
+    if (objectDefaults && (objectDefaults.spDef || objectDefaults.lnDef || objectDefaults.txDef)) {
+      const od = {};
+      if (objectDefaults.spDef !== void 0) {
+        od["a:spDef"] = objectDefaults.spDef;
+      }
+      if (objectDefaults.lnDef !== void 0) {
+        od["a:lnDef"] = objectDefaults.lnDef;
+      }
+      if (objectDefaults.txDef !== void 0) {
+        od["a:txDef"] = objectDefaults.txDef;
+      }
+      themeRoot["a:objectDefaults"] = od;
+    } else {
+      themeRoot["a:objectDefaults"] = {};
+    }
+    const extraClr = this.masterThemeExtraClrSchemeLst.get(themePath);
+    themeRoot["a:extraClrSchemeLst"] = extraClr !== void 0 ? extraClr : {};
+    const custClr = this.masterThemeCustClrLst.get(themePath);
+    if (custClr !== void 0) {
+      themeRoot["a:custClrLst"] = custClr;
+    }
+    const themeExt = this.masterThemeExtLst.get(themePath);
+    if (themeExt !== void 0) {
+      themeRoot["a:extLst"] = themeExt;
+    }
+    const doc = {
+      "?xml": { "@_version": "1.0", "@_encoding": "UTF-8", "@_standalone": "yes" },
+      "a:theme": themeRoot
+    };
+    try {
+      return this.builder.build(doc);
+    } catch (error) {
+      console.warn(`Failed to build theme XML for ${themePath}:`, error);
+      return void 0;
+    }
+  }
+  /**
+   * Build the `a:clrScheme` XmlObject from a colour map. Each slot
+   * value is interpreted as either a `#RRGGBB` srgb hex or a known
+   * sysClr token (currently always emitted as srgbClr — the in-memory
+   * map is hex-typed; sysClr round-trip belongs to the broader C-H3
+   * fix to preserve original color XML and is out of scope here).
+   */
+  buildClrSchemeObject(schemeName, colorMap) {
+    const slot = (key) => {
+      const hex = String(colorMap[key] || "").replace(/^#/, "");
+      const srgb = hex.length === 6 ? hex.toUpperCase() : "000000";
+      return { "a:srgbClr": { "@_val": srgb } };
+    };
+    return {
+      "@_name": schemeName,
+      "a:dk1": slot("dk1"),
+      "a:lt1": slot("lt1"),
+      "a:dk2": slot("dk2"),
+      "a:lt2": slot("lt2"),
+      "a:accent1": slot("accent1"),
+      "a:accent2": slot("accent2"),
+      "a:accent3": slot("accent3"),
+      "a:accent4": slot("accent4"),
+      "a:accent5": slot("accent5"),
+      "a:accent6": slot("accent6"),
+      "a:hlink": slot("hlink"),
+      "a:folHlink": slot("folHlink")
+    };
+  }
+  /**
+   * Build the `a:fontScheme` XmlObject from a font map plus per-script
+   * font tables.
+   *
+   * Phase 4 Stream A / M4.
+   */
+  buildFontSchemeObject(schemeName, fontMap, majorScripts, minorScripts) {
+    const buildFontGroup = (latinKey, eaKey, csKey, scripts) => {
+      const group = {
+        "a:latin": { "@_typeface": fontMap[latinKey] || "Calibri" },
+        "a:ea": { "@_typeface": fontMap[eaKey] || "" },
+        "a:cs": { "@_typeface": fontMap[csKey] || "" }
+      };
+      const scriptKeys = Object.keys(scripts);
+      if (scriptKeys.length > 0) {
+        const fontEntries = scriptKeys.map((script) => ({
+          "@_script": script,
+          "@_typeface": scripts[script]
+        }));
+        group["a:font"] = fontEntries.length === 1 ? fontEntries[0] : fontEntries;
+      }
+      return group;
+    };
+    return {
+      "@_name": schemeName,
+      "a:majorFont": buildFontGroup("mj-lt", "mj-ea", "mj-cs", majorScripts),
+      "a:minorFont": buildFontGroup("mn-lt", "mn-ea", "mn-cs", minorScripts)
+    };
+  }
+  /**
+   * Re-parse the original theme XML and pluck out a subtree by path,
+   * returning the raw parser object. Returns `undefined` when the
+   * original is missing or the path doesn't exist.
+   *
+   * Used to preserve `a:fmtScheme` byte-for-byte through a regenerate
+   * round-trip, since the in-memory PptxThemeFormatScheme is lossy.
+   */
+  extractRawSubtreeFromOriginal(themePath, path2) {
+    const original = this.originalThemeXmlByPath.get(themePath);
+    if (!original) {
+      return void 0;
+    }
+    try {
+      const parsed = this.parser.parse(original);
+      let cursor = parsed;
+      for (const segment of path2) {
+        if (cursor && typeof cursor === "object" && segment in cursor) {
+          cursor = cursor[segment];
+        } else {
+          return void 0;
+        }
+      }
+      return cursor;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Last-resort minimal `<a:fmtScheme>` body. Mirrors the SDK new-deck
+   * builder's output for new presentations, scaled down to the smallest
+   * schema-valid form.
+   */
+  buildMinimalFmtScheme(name) {
+    const phClrSolid = { "a:solidFill": { "a:schemeClr": { "@_val": "phClr" } } };
+    return {
+      "@_name": name,
+      "a:fillStyleLst": {
+        "a:solidFill": [{ "a:schemeClr": { "@_val": "phClr" } }],
+        "a:gradFill": []
+      },
+      "a:lnStyleLst": {
+        "a:ln": [
+          {
+            "@_w": "6350",
+            "@_cap": "flat",
+            "@_cmpd": "sng",
+            "@_algn": "ctr",
+            ...phClrSolid,
+            "a:prstDash": { "@_val": "solid" },
+            "a:miter": { "@_lim": "800000" }
+          },
+          {
+            "@_w": "12700",
+            "@_cap": "flat",
+            "@_cmpd": "sng",
+            "@_algn": "ctr",
+            ...phClrSolid,
+            "a:prstDash": { "@_val": "solid" },
+            "a:miter": { "@_lim": "800000" }
+          },
+          {
+            "@_w": "19050",
+            "@_cap": "flat",
+            "@_cmpd": "sng",
+            "@_algn": "ctr",
+            ...phClrSolid,
+            "a:prstDash": { "@_val": "solid" },
+            "a:miter": { "@_lim": "800000" }
+          }
+        ]
+      },
+      "a:effectStyleLst": {
+        "a:effectStyle": [{ "a:effectLst": {} }, { "a:effectLst": {} }, { "a:effectLst": {} }]
+      },
+      "a:bgFillStyleLst": {
+        "a:solidFill": [{ "a:schemeClr": { "@_val": "phClr" } }],
+        "a:gradFill": []
+      }
+    };
+  }
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeSavePipeline.ts
-var PptxHandlerRuntime34 = class _PptxHandlerRuntime extends PptxHandlerRuntime33 {
+var PptxHandlerRuntime35 = class _PptxHandlerRuntime extends PptxHandlerRuntime34 {
   /**
    * Resolve the effective conformance class for this save operation.
    *
@@ -31436,6 +33193,7 @@ var PptxHandlerRuntime34 = class _PptxHandlerRuntime extends PptxHandlerRuntime3
     for (const [masterPath, masterXmlObj] of this.masterXmlMap.entries()) {
       this.zip.file(masterPath, this.builder.build(masterXmlObj));
     }
+    await this.persistThemeParts();
     await this.applyEmbeddedFontPreservation(options?.embeddedFonts);
     if (this.presentationData) {
       this.presentationSaveBuilder.applySaveOptions({
@@ -31525,7 +33283,7 @@ var PptxHandlerRuntime34 = class _PptxHandlerRuntime extends PptxHandlerRuntime3
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeElementParsing.ts
-var PptxHandlerRuntime35 = class _PptxHandlerRuntime extends PptxHandlerRuntime34 {
+var PptxHandlerRuntime36 = class _PptxHandlerRuntime extends PptxHandlerRuntime35 {
   /**
    * Parse media data (video/audio path and MIME type) from graphic frame data.
    */
@@ -31747,7 +33505,7 @@ var PptxHandlerRuntime35 = class _PptxHandlerRuntime extends PptxHandlerRuntime3
 };
 
 // src/core/core/runtime/PptxHandlerRuntimePlaceholderLookup.ts
-var PptxHandlerRuntime36 = class extends PptxHandlerRuntime35 {
+var PptxHandlerRuntime37 = class extends PptxHandlerRuntime36 {
   findPlaceholderInShapeTree(spTree, expected) {
     if (!spTree) {
       return void 0;
@@ -31900,7 +33658,7 @@ var PptxHandlerRuntime36 = class extends PptxHandlerRuntime35 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeGeometryParsing.ts
-var PptxHandlerRuntime37 = class extends PptxHandlerRuntime36 {
+var PptxHandlerRuntime38 = class extends PptxHandlerRuntime37 {
   parseGeometryAdjustments(prstGeom) {
     if (!prstGeom) {
       return void 0;
@@ -32009,6 +33767,103 @@ var PptxHandlerRuntime37 = class extends PptxHandlerRuntime36 {
     }
     return handles.length > 0 ? handles : void 0;
   }
+  /**
+   * Extract `a:gdLst`/`a:ahLst`/`a:cxnLst`/`a:rect` raw XML from a `a:custGeom`
+   * node so they can be re-emitted on save when the geometry is edited.
+   * Returns `undefined` when none of these auxiliary children carry data.
+   */
+  extractCustomGeometryRawData(custGeom) {
+    if (!custGeom) {
+      return void 0;
+    }
+    const isNonEmpty = (node) => {
+      if (node === void 0 || node === null) {
+        return false;
+      }
+      if (typeof node !== "object") {
+        return true;
+      }
+      return Object.keys(node).length > 0;
+    };
+    const result = {};
+    const gdLst = custGeom["a:gdLst"];
+    if (isNonEmpty(gdLst)) {
+      result.gdLstXml = gdLst;
+    }
+    const ahLst = custGeom["a:ahLst"];
+    if (isNonEmpty(ahLst)) {
+      result.ahLstXml = ahLst;
+    }
+    const cxnLst = custGeom["a:cxnLst"];
+    if (isNonEmpty(cxnLst)) {
+      result.cxnLstXml = cxnLst;
+    }
+    const rect = custGeom["a:rect"];
+    if (isNonEmpty(rect)) {
+      result.rectXml = rect;
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+  }
+  /**
+   * Build structured `CustomGeometryPath[]` from a parsed `a:custGeom` node,
+   * including per-path `@fill`/`@stroke`/`@extrusionOk` attributes so they
+   * survive a round-trip when the path list is later regenerated.
+   *
+   * Falls back to SVG → structured-path conversion when no structured path
+   * info is otherwise available.
+   */
+  buildStructuredCustomGeometryPaths(custGeom, pathData, pathWidth, pathHeight) {
+    if (!custGeom) {
+      return void 0;
+    }
+    const pathLst = custGeom["a:pathLst"];
+    if (!pathLst) {
+      return void 0;
+    }
+    const pathNodes = this.ensureArray(pathLst["a:path"]);
+    if (pathNodes.length === 0) {
+      return void 0;
+    }
+    const segments = svgToCustomGeometryPaths(pathData, pathWidth, pathHeight);
+    if (segments.length === 0) {
+      return void 0;
+    }
+    const validFillModes = /* @__PURE__ */ new Set([
+      "norm",
+      "lighten",
+      "lightenLess",
+      "darken",
+      "darkenLess",
+      "none"
+    ]);
+    const parseBoolAttr2 = (value) => {
+      if (value === void 0 || value === null || value === "") {
+        return void 0;
+      }
+      if (value === "1" || value === "true" || value === true) {
+        return true;
+      }
+      if (value === "0" || value === "false" || value === false) {
+        return false;
+      }
+      return void 0;
+    };
+    const target = segments[0];
+    const firstNode = pathNodes[0];
+    const fillAttr = String(firstNode["@_fill"] ?? "").trim();
+    if (validFillModes.has(fillAttr)) {
+      target.fillMode = fillAttr;
+    }
+    const strokeAttr = parseBoolAttr2(firstNode["@_stroke"]);
+    if (strokeAttr !== void 0) {
+      target.stroke = strokeAttr;
+    }
+    const extrusionAttr = parseBoolAttr2(firstNode["@_extrusionOk"]);
+    if (extrusionAttr !== void 0) {
+      target.extrusionOk = extrusionAttr;
+    }
+    return segments;
+  }
   parseCustomGeometry(custGeom, shapeWidth, shapeHeight) {
     if (!custGeom || !custGeom["a:pathLst"] || !custGeom["a:pathLst"]?.["a:path"]) {
       return null;
@@ -32077,7 +33932,7 @@ var PptxHandlerRuntime37 = class extends PptxHandlerRuntime36 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeShapeImageFill.ts
-var PptxHandlerRuntime38 = class _PptxHandlerRuntime extends PptxHandlerRuntime37 {
+var PptxHandlerRuntime39 = class _PptxHandlerRuntime extends PptxHandlerRuntime38 {
   /**
    * Parse a shape that has an image fill (a:blipFill inside spPr)
    * This handles shapes like rectangles filled with images (e.g., wood texture backgrounds)
@@ -32277,7 +34132,7 @@ var PptxHandlerRuntime38 = class _PptxHandlerRuntime extends PptxHandlerRuntime3
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeTextDefaults.ts
-var PptxHandlerRuntime39 = class extends PptxHandlerRuntime38 {
+var PptxHandlerRuntime40 = class extends PptxHandlerRuntime39 {
   /**
    * Apply {@link PlaceholderDefaults} body-level properties to a
    * {@link TextStyle} as fallback values (only sets fields that are
@@ -32401,7 +34256,7 @@ var PptxHandlerRuntime39 = class extends PptxHandlerRuntime38 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeBulletParsing.ts
-var PptxHandlerRuntime40 = class extends PptxHandlerRuntime39 {
+var PptxHandlerRuntime41 = class extends PptxHandlerRuntime40 {
   resolveParagraphBulletInfo(paragraph, paragraphIndex, txBody, inheritedTxBody, isBodyPlaceholder = false, slidePath) {
     if (!paragraph) {
       return null;
@@ -32432,7 +34287,7 @@ var PptxHandlerRuntime40 = class extends PptxHandlerRuntime39 {
       if (candidate["a:buNone"]) {
         return { none: true };
       }
-      if (candidate["a:buChar"] || candidate["a:buAutoNum"] || candidate["a:buBlip"]) {
+      if (candidate["a:buChar"] || candidate["a:buAutoNum"] || candidate["a:buBlip"] || candidate["a:buFontTx"] !== void 0 || candidate["a:buClrTx"] !== void 0 || candidate["a:buSzTx"] !== void 0) {
         resolvedBulletProps = candidate;
         break;
       }
@@ -32446,6 +34301,7 @@ var PptxHandlerRuntime40 = class extends PptxHandlerRuntime39 {
     }
     const buFont = resolvedBulletProps["a:buFont"];
     const fontFamily = buFont?.["@_typeface"] ? String(buFont["@_typeface"]) : void 0;
+    const fontInherit = resolvedBulletProps["a:buFontTx"] !== void 0;
     const buSzPct = resolvedBulletProps["a:buSzPct"];
     let sizePercent;
     if (buSzPct?.["@_val"] !== void 0) {
@@ -32462,6 +34318,7 @@ var PptxHandlerRuntime40 = class extends PptxHandlerRuntime39 {
         sizePts = ptsRaw / 100;
       }
     }
+    const sizeInherit = resolvedBulletProps["a:buSzTx"] !== void 0;
     const buClr = resolvedBulletProps["a:buClr"];
     let color;
     if (buClr) {
@@ -32470,6 +34327,7 @@ var PptxHandlerRuntime40 = class extends PptxHandlerRuntime39 {
         color = String(srgb["@_val"]);
       }
     }
+    const colorInherit = resolvedBulletProps["a:buClrTx"] !== void 0;
     const bulletChar = String(
       resolvedBulletProps["a:buChar"]?.["@_char"] || ""
     );
@@ -32479,7 +34337,10 @@ var PptxHandlerRuntime40 = class extends PptxHandlerRuntime39 {
         fontFamily,
         sizePercent,
         sizePts,
-        color
+        color,
+        ...fontInherit ? { fontInherit: true } : {},
+        ...colorInherit ? { colorInherit: true } : {},
+        ...sizeInherit ? { sizeInherit: true } : {}
       };
     }
     const autoNum = resolvedBulletProps["a:buAutoNum"];
@@ -32494,7 +34355,10 @@ var PptxHandlerRuntime40 = class extends PptxHandlerRuntime39 {
         fontFamily,
         sizePercent,
         sizePts,
-        color
+        color,
+        ...fontInherit ? { fontInherit: true } : {},
+        ...colorInherit ? { colorInherit: true } : {},
+        ...sizeInherit ? { sizeInherit: true } : {}
       };
     }
     const buBlip = resolvedBulletProps["a:buBlip"];
@@ -32606,7 +34470,7 @@ var PptxHandlerRuntime40 = class extends PptxHandlerRuntime39 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeShapeBodyParsing.ts
-var PptxHandlerRuntime41 = class _PptxHandlerRuntime extends PptxHandlerRuntime40 {
+var PptxHandlerRuntime42 = class _PptxHandlerRuntime extends PptxHandlerRuntime41 {
   /**
    * Parse `a:spLocks` attributes into a structured {@link PptxShapeLocks} object.
    * Returns `undefined` when the node is absent or contains no lock attributes.
@@ -32701,7 +34565,8 @@ var PptxHandlerRuntime41 = class _PptxHandlerRuntime extends PptxHandlerRuntime4
     if (Number.isFinite(spcColRaw) && spcColRaw > 0) {
       textStyle.columnSpacing = spcColRaw / _PptxHandlerRuntime.EMU_PER_PX;
     }
-    const hOverflow = String(bodyPr["@_hOverflow"] || "").trim();
+    const hOverflowRaw = bodyPr["@_horzOverflow"] ?? bodyPr["@_hOverflow"];
+    const hOverflow = String(hOverflowRaw || "").trim();
     if (hOverflow === "overflow" || hOverflow === "clip") {
       textStyle.hOverflow = hOverflow;
     }
@@ -32884,7 +34749,7 @@ var PptxHandlerRuntime41 = class _PptxHandlerRuntime extends PptxHandlerRuntime4
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeShapeTextParsing.ts
-var PptxHandlerRuntime42 = class _PptxHandlerRuntime extends PptxHandlerRuntime41 {
+var PptxHandlerRuntime43 = class _PptxHandlerRuntime extends PptxHandlerRuntime42 {
   /**
    * Resolve paragraph-level styles (alignment, spacing, margins, tabs,
    * level styles) for a single paragraph.  Modifies `textStyle` in place
@@ -33066,7 +34931,7 @@ var PptxHandlerRuntime42 = class _PptxHandlerRuntime extends PptxHandlerRuntime4
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeShapeParagraphContentParsing.ts
-var PptxHandlerRuntime43 = class extends PptxHandlerRuntime42 {
+var PptxHandlerRuntime44 = class extends PptxHandlerRuntime43 {
   /**
    * Collect text content (runs, fields, equations, bullets) for a single
    * paragraph and return text parts + segments.  The returned `seedStyle`
@@ -33249,6 +35114,23 @@ var PptxHandlerRuntime43 = class extends PptxHandlerRuntime42 {
       parts.push("\n");
       segments.push({ text: "\n", style: { ...mergedDefaultRunStyle } });
     }
+    const firstSegmentIndex = segments.length === 0 ? -1 : 0;
+    if (firstSegmentIndex >= 0) {
+      const pPrRaw = p["a:pPr"];
+      const lvlRaw = pPrRaw?.["@_lvl"];
+      if (lvlRaw !== void 0) {
+        const lvlParsed = Number.parseInt(String(lvlRaw), 10);
+        if (Number.isFinite(lvlParsed) && lvlParsed > 0) {
+          segments[firstSegmentIndex].paragraphLevel = Math.min(Math.max(lvlParsed, 0), 8);
+        }
+      }
+      const endParaRPrRaw = p["a:endParaRPr"];
+      if (endParaRPrRaw && typeof endParaRPrRaw === "object") {
+        segments[firstSegmentIndex].endParaRunProperties = {
+          ...endParaRPrRaw
+        };
+      }
+    }
     return { parts, segments, seedStyle };
   }
   /**
@@ -33358,7 +35240,7 @@ var PptxHandlerRuntime43 = class extends PptxHandlerRuntime42 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeShapeParsing.ts
-var PptxHandlerRuntime44 = class _PptxHandlerRuntime extends PptxHandlerRuntime43 {
+var PptxHandlerRuntime45 = class _PptxHandlerRuntime extends PptxHandlerRuntime44 {
   parseShape(shape, id, slidePath) {
     try {
       const spPr = shape["p:spPr"];
@@ -33394,6 +35276,7 @@ var PptxHandlerRuntime44 = class _PptxHandlerRuntime extends PptxHandlerRuntime4
       let pathData;
       let pathWidth;
       let pathHeight;
+      let customGeometryRawData;
       const custGeom = effectiveSpPr?.["a:custGeom"];
       if (custGeom) {
         const customPath = this.parseCustomGeometry(
@@ -33406,6 +35289,7 @@ var PptxHandlerRuntime44 = class _PptxHandlerRuntime extends PptxHandlerRuntime4
           pathData = customPath.pathData;
           pathWidth = customPath.pathWidth;
           pathHeight = customPath.pathHeight;
+          customGeometryRawData = this.extractCustomGeometryRawData(custGeom);
         }
       }
       const geomNode = custGeom ?? effectiveSpPr?.["a:prstGeom"];
@@ -33563,7 +35447,8 @@ var PptxHandlerRuntime44 = class _PptxHandlerRuntime extends PptxHandlerRuntime4
         type: "shape",
         pathData,
         pathWidth,
-        pathHeight
+        pathHeight,
+        customGeometryRawData
       };
     } catch (e) {
       console.warn(`[pptx] Skipping shape element (${id}):`, e);
@@ -33573,7 +35458,7 @@ var PptxHandlerRuntime44 = class _PptxHandlerRuntime extends PptxHandlerRuntime4
 };
 
 // src/core/core/runtime/PptxHandlerRuntimePictureParsing.ts
-var PptxHandlerRuntime45 = class _PptxHandlerRuntime extends PptxHandlerRuntime44 {
+var PptxHandlerRuntime46 = class _PptxHandlerRuntime extends PptxHandlerRuntime45 {
   async parsePicture(pic, id, slidePath) {
     try {
       const spPr = pic["p:spPr"];
@@ -33812,7 +35697,7 @@ var PptxHandlerRuntime45 = class _PptxHandlerRuntime extends PptxHandlerRuntime4
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeSpTreeParsing.ts
-var PptxHandlerRuntime46 = class _PptxHandlerRuntime extends PptxHandlerRuntime45 {
+var PptxHandlerRuntime47 = class _PptxHandlerRuntime extends PptxHandlerRuntime46 {
   /**
    * Known element tag names that appear as direct children of `p:spTree`
    * (or `p:grpSp`) and represent renderable shapes/objects.
@@ -34157,9 +36042,18 @@ var PptxHandlerRuntime46 = class _PptxHandlerRuntime extends PptxHandlerRuntime4
    * Unwrap mc:AlternateContent elements within a shape tree (or group),
    * merging selected branch children into the parent element arrays.
    * Delegates to the standalone alternate-content utility.
+   *
+   * Records each consumed AC envelope in {@link alternateContentBlockByRawXml}
+   * so the save layer can re-emit the original `<mc:Choice>` /
+   * `<mc:Fallback>` shape on dirty save (CC-4).
    */
   unwrapAlternateContent(container) {
-    unwrapAlternateContent(container);
+    const blocks = unwrapAlternateContent(container);
+    for (const block of blocks) {
+      for (const ref of block.childRefs) {
+        this.alternateContentBlockByRawXml.set(ref.node, block);
+      }
+    }
   }
   /**
    * Forward declaration – implemented in PptxHandlerRuntimeGroupParsing.
@@ -34170,7 +36064,7 @@ var PptxHandlerRuntime46 = class _PptxHandlerRuntime extends PptxHandlerRuntime4
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeGroupParsing.ts
-var PptxHandlerRuntime47 = class _PptxHandlerRuntime extends PptxHandlerRuntime46 {
+var PptxHandlerRuntime48 = class _PptxHandlerRuntime extends PptxHandlerRuntime47 {
   async parseGroupShape(group, baseId, slidePath, rawXmlStr) {
     const grpSpPr = group["p:grpSpPr"];
     const xfrm = grpSpPr?.["a:xfrm"];
@@ -34343,7 +36237,7 @@ var PptxHandlerRuntime47 = class _PptxHandlerRuntime extends PptxHandlerRuntime4
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeSlideParsing.ts
-var PptxHandlerRuntime48 = class extends PptxHandlerRuntime47 {
+var PptxHandlerRuntime49 = class extends PptxHandlerRuntime48 {
   /**
    * Parse text body from a connector shape (p:cxnSp > p:txBody).
    * Uses the same text run extraction logic as regular shapes but
@@ -34455,7 +36349,7 @@ var PptxHandlerRuntime48 = class extends PptxHandlerRuntime47 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeColorAndEffects.ts
-var PptxHandlerRuntime49 = class extends PptxHandlerRuntime48 {
+var PptxHandlerRuntime50 = class extends PptxHandlerRuntime49 {
   /**
    * Forward declaration – implemented in PptxHandlerRuntimeThemeProcessing.
    * Re-resolves gradient stops by substituting `phClr` with the given colour.
@@ -34496,8 +36390,9 @@ var PptxHandlerRuntime49 = class extends PptxHandlerRuntime48 {
       return void 0;
     }
     const resolvedKey = normalized === "phclr" ? "accent1" : normalized;
-    if (this.currentSlideClrMapOverride) {
-      const remapped = this.currentSlideClrMapOverride[resolvedKey];
+    const overrideMap = this.currentSlideClrMapOverride ?? this.currentMasterClrMap;
+    if (overrideMap) {
+      const remapped = overrideMap[resolvedKey];
       if (remapped) {
         return this.themeColorMap[remapped] || this.getDefaultSchemeColorMap()[remapped];
       }
@@ -34580,7 +36475,7 @@ var PptxHandlerRuntime49 = class extends PptxHandlerRuntime48 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeBackgroundParsing.ts
-var PptxHandlerRuntime50 = class extends PptxHandlerRuntime49 {
+var PptxHandlerRuntime51 = class extends PptxHandlerRuntime50 {
   async extractBackgroundImage(slideXml2, slidePath, rootElement = "p:sld") {
     try {
       const bg = slideXml2[rootElement]?.["p:cSld"]?.["p:bg"];
@@ -34791,7 +36686,7 @@ var PptxHandlerRuntime50 = class extends PptxHandlerRuntime49 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeSlideUtils.ts
-var PptxHandlerRuntime51 = class extends PptxHandlerRuntime50 {
+var PptxHandlerRuntime52 = class extends PptxHandlerRuntime51 {
   /**
    * Retrieve the background gradient from a layout, falling back to master.
    */
@@ -34862,6 +36757,64 @@ var PptxHandlerRuntime51 = class extends PptxHandlerRuntime50 {
     }
     return void 0;
   }
+  /**
+   * Find the master file path referenced by a layout via its relationships.
+   */
+  findMasterPathForLayoutBase(layoutPath) {
+    const layoutRels = this.slideRelsMap.get(layoutPath);
+    if (!layoutRels) {
+      return void 0;
+    }
+    for (const [, target] of layoutRels.entries()) {
+      if (target.includes("slideMaster")) {
+        const layoutDir = layoutPath.substring(0, layoutPath.lastIndexOf("/") + 1);
+        return target.startsWith("..") ? this.resolvePath(layoutDir, target) : `ppt/${target.replace("../", "")}`;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Switch the active master state (clrMap + theme color/font/format
+   * scheme) so that scheme-colour resolution for the slide currently
+   * being parsed walks through the correct master.
+   *
+   * Multi-master decks must resolve scheme colours against each slide's
+   * own master rather than always against `masterFiles[0]`.
+   *
+   * Phase 2 Stream B / C-H4.
+   */
+  async setActiveMasterForSlide(slidePath) {
+    const layoutPath = this.findLayoutPathForSlide(slidePath);
+    if (!layoutPath) {
+      this.currentMasterClrMap = null;
+      this.themeColorMap = { ...this.globalThemeColorMapSnapshot };
+      this.themeFontMap = { ...this.globalThemeFontMapSnapshot };
+      this.themeFormatScheme = this.globalThemeFormatSchemeSnapshot;
+      return;
+    }
+    if (!this.slideRelsMap.has(layoutPath)) {
+      const layoutRelsPath = `${layoutPath.replace("slideLayouts/", "slideLayouts/_rels/")}.rels`;
+      try {
+        await this.loadSlideRelationships(layoutPath, layoutRelsPath);
+      } catch {
+      }
+    }
+    const masterPath = this.findMasterPathForLayoutBase(layoutPath);
+    if (!masterPath) {
+      this.currentMasterClrMap = null;
+      this.themeColorMap = { ...this.globalThemeColorMapSnapshot };
+      this.themeFontMap = { ...this.globalThemeFontMapSnapshot };
+      this.themeFormatScheme = this.globalThemeFormatSchemeSnapshot;
+      return;
+    }
+    this.currentMasterClrMap = this.masterClrMaps.get(masterPath) ?? null;
+    const masterColorMap = this.masterThemeColorMaps.get(masterPath);
+    this.themeColorMap = masterColorMap ? { ...masterColorMap } : { ...this.globalThemeColorMapSnapshot };
+    const masterFontMap = this.masterThemeFontMaps.get(masterPath);
+    this.themeFontMap = masterFontMap ? { ...masterFontMap } : { ...this.globalThemeFontMapSnapshot };
+    const masterFormatScheme = this.masterThemeFormatSchemes.get(masterPath);
+    this.themeFormatScheme = masterFormatScheme ?? this.globalThemeFormatSchemeSnapshot;
+  }
   /**
    * Extract the `p:bg/@showAnimation` flag from a slide's XML.
    * Returns `true` when the background should animate, `false` when
@@ -35002,7 +36955,7 @@ var PptxHandlerRuntime51 = class extends PptxHandlerRuntime50 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimePlaceholderStyles.ts
-var PptxHandlerRuntime52 = class _PptxHandlerRuntime extends PptxHandlerRuntime51 {
+var PptxHandlerRuntime53 = class _PptxHandlerRuntime extends PptxHandlerRuntime52 {
   /**
    * Parse a single `a:lvlXpPr` node into a structured
    * {@link PlaceholderTextLevelStyle}.
@@ -35123,7 +37076,7 @@ var PptxHandlerRuntime52 = class _PptxHandlerRuntime extends PptxHandlerRuntime5
 };
 
 // src/core/core/runtime/PptxHandlerRuntimePlaceholderDefaults.ts
-var PptxHandlerRuntime53 = class _PptxHandlerRuntime extends PptxHandlerRuntime52 {
+var PptxHandlerRuntime54 = class _PptxHandlerRuntime extends PptxHandlerRuntime53 {
   /**
    * Extract structured {@link PlaceholderDefaults} from a layout or master
    * shape that carries a `p:ph` element.
@@ -35266,7 +37219,118 @@ var PptxHandlerRuntime53 = class _PptxHandlerRuntime extends PptxHandlerRuntime5
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeMasterElements.ts
-var PptxHandlerRuntime54 = class extends PptxHandlerRuntime53 {
+function parseHeaderFooterFlags(hf) {
+  if (!hf) {
+    return void 0;
+  }
+  const result = {};
+  if (hf["@_hdr"] !== void 0) {
+    result.hasHeader = String(hf["@_hdr"]) !== "0";
+  }
+  if (hf["@_ftr"] !== void 0) {
+    result.hasFooter = String(hf["@_ftr"]) !== "0";
+  }
+  if (hf["@_dt"] !== void 0) {
+    result.hasDateTime = String(hf["@_dt"]) !== "0";
+  }
+  if (hf["@_sldNum"] !== void 0) {
+    result.hasSlideNumber = String(hf["@_sldNum"]) !== "0";
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+var PptxHandlerRuntime55 = class extends PptxHandlerRuntime54 {
+  /**
+   * Parse a `CT_TextListStyle` node (`a:defPPr` + `a:lvl1pPr` … `a:lvl9pPr`)
+   * into a level-keyed style map. Used for `<p:txStyles>` children
+   * (`p:titleStyle`, `p:bodyStyle`, `p:otherStyle`) — see ECMA-376 §19.3.1.52.
+   */
+  parseTextListStyle(node) {
+    if (!node) {
+      return void 0;
+    }
+    const levels = {};
+    const defParsed = this.parsePlaceholderLevelStyle(node["a:defPPr"]);
+    if (defParsed) {
+      levels[-1] = defParsed;
+    }
+    for (let lvl = 1; lvl <= 9; lvl++) {
+      const parsed = this.parsePlaceholderLevelStyle(
+        node[`a:lvl${lvl}pPr`]
+      );
+      if (parsed) {
+        levels[lvl - 1] = parsed;
+      }
+    }
+    return Object.keys(levels).length > 0 ? levels : void 0;
+  }
+  /**
+   * Parse `<p:txStyles>` from a slide-master XML object into a structured
+   * {@link PptxMasterTextStyles}. Used to populate `PptxSlideMaster.txStyles`
+   * so the title/body/other text-style cascade (P-H1) is visible on the
+   * typed model.
+   */
+  parseMasterTxStyles(masterXml) {
+    const txStyles = masterXml?.["p:txStyles"];
+    if (!txStyles) {
+      return void 0;
+    }
+    const titleStyle = this.parseTextListStyle(txStyles["p:titleStyle"]);
+    const bodyStyle = this.parseTextListStyle(txStyles["p:bodyStyle"]);
+    const otherStyle = this.parseTextListStyle(txStyles["p:otherStyle"]);
+    if (!titleStyle && !bodyStyle && !otherStyle) {
+      return void 0;
+    }
+    const result = {};
+    if (titleStyle) {
+      result.titleStyle = titleStyle;
+    }
+    if (bodyStyle) {
+      result.bodyStyle = bodyStyle;
+    }
+    if (otherStyle) {
+      result.otherStyle = otherStyle;
+    }
+    return result;
+  }
+  /**
+   * Enrich an array of {@link PptxSlideMaster} entries (already produced by
+   * `parseSlideMasters`) with parsed `<p:txStyles>`. Loads each master's XML
+   * once, parses, and caches it in `masterXmlMap` for downstream consumers.
+   *
+   * Also stores the parsed result on the per-master cache so that the
+   * inheritance chain in `applyMasterTextStyleCascade` can find it without
+   * re-parsing.
+   */
+  async enrichSlideMastersWithTxStyles(slideMasters) {
+    for (const master of slideMasters) {
+      try {
+        let masterXmlObj = this.masterXmlMap.get(master.path);
+        if (!masterXmlObj) {
+          const xmlStr = await this.zip.file(master.path)?.async("string");
+          if (!xmlStr) {
+            continue;
+          }
+          masterXmlObj = this.parser.parse(xmlStr);
+          this.masterXmlMap.set(master.path, masterXmlObj);
+        }
+        const sldMaster = masterXmlObj["p:sldMaster"];
+        if (!sldMaster) {
+          continue;
+        }
+        const parsed = this.parseMasterTxStyles(sldMaster);
+        if (parsed) {
+          master.txStyles = parsed;
+          this.masterTxStylesCache.set(master.path, parsed);
+        }
+        const hf = parseHeaderFooterFlags(sldMaster["p:hf"]);
+        if (hf) {
+          master.headerFooter = hf;
+        }
+      } catch (e) {
+        console.warn("Failed to parse master txStyles:", e);
+      }
+    }
+  }
   parsePresentationDefaultTextStyle() {
     const presentation = this.presentationData?.["p:presentation"];
     const defaultTextStyle = presentation?.["p:defaultTextStyle"];
@@ -35422,7 +37486,7 @@ var PptxHandlerRuntime54 = class extends PptxHandlerRuntime53 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeLayoutElements.ts
-var PptxHandlerRuntime55 = class extends PptxHandlerRuntime54 {
+var PptxHandlerRuntime56 = class extends PptxHandlerRuntime55 {
   async getLayoutElements(slidePath) {
     const slideRels = this.slideRelsMap.get(slidePath);
     if (!slideRels) {
@@ -35546,10 +37610,10 @@ var PptxHandlerRuntime55 = class extends PptxHandlerRuntime54 {
           }
         }
       }
-      this.currentSlideClrMapOverride = prevClrMapOverride;
       const layoutShowMasterSp = layoutXmlObj["p:sldLayout"]?.["@_showMasterSp"];
       const showMasterSp = layoutShowMasterSp === void 0 || String(layoutShowMasterSp).trim().toLowerCase() !== "0" && String(layoutShowMasterSp).trim().toLowerCase() !== "false";
       const masterElements = showMasterSp ? await this.getMasterElements(layoutPath) : [];
+      this.currentSlideClrMapOverride = prevClrMapOverride;
       const allElements = [...masterElements, ...elements];
       this.layoutCache.set(layoutPath, allElements);
       return allElements;
@@ -35561,7 +37625,7 @@ var PptxHandlerRuntime55 = class extends PptxHandlerRuntime54 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeThemeFormatScheme.ts
-var PptxHandlerRuntime56 = class _PptxHandlerRuntime extends PptxHandlerRuntime55 {
+var PptxHandlerRuntime57 = class _PptxHandlerRuntime extends PptxHandlerRuntime56 {
   /**
    * Collect fill-style children from a style list node, preserving
    * document order.  Handles `a:solidFill`, `a:gradFill`, `a:pattFill`,
@@ -35803,7 +37867,7 @@ var PptxHandlerRuntime56 = class _PptxHandlerRuntime extends PptxHandlerRuntime5
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeThemeOverrides.ts
-var PptxHandlerRuntime57 = class extends PptxHandlerRuntime56 {
+var PptxHandlerRuntime58 = class extends PptxHandlerRuntime57 {
   /**
    * Parse the `a:fmtScheme` element from the theme into a structured
    * {@link PptxThemeFormatScheme}.  Each sub-list (fillStyleLst, lnStyleLst,
@@ -36000,8 +38064,10 @@ var PptxHandlerRuntime57 = class extends PptxHandlerRuntime56 {
       }
       const fontScheme = root["a:fontScheme"];
       if (fontScheme) {
-        const majorLatin = fontScheme["a:majorFont"]?.["a:latin"];
-        const minorLatin = fontScheme["a:minorFont"]?.["a:latin"];
+        const majorFontNode = fontScheme["a:majorFont"];
+        const minorFontNode = fontScheme["a:minorFont"];
+        const majorLatin = majorFontNode?.["a:latin"];
+        const minorLatin = minorFontNode?.["a:latin"];
         const majorFont = this.normalizeTypefaceToken(String(majorLatin?.["@_typeface"] || ""));
         const minorFont = this.normalizeTypefaceToken(String(minorLatin?.["@_typeface"] || ""));
         if (!result.colorOverrides) {
@@ -36024,13 +38090,46 @@ var PptxHandlerRuntime57 = class extends PptxHandlerRuntime56 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeThemeRefResolution.ts
-var PptxHandlerRuntime58 = class extends PptxHandlerRuntime57 {
+var COLOR_CHOICE_KEYS2 = [
+  "a:scrgbClr",
+  "a:srgbClr",
+  "a:hslClr",
+  "a:sysClr",
+  "a:schemeClr",
+  "a:prstClr"
+];
+var PptxHandlerRuntime59 = class extends PptxHandlerRuntime58 {
+  /**
+   * Pull the verbatim colour-choice child out of a style-matrix-reference
+   * element (`a:lnRef`/`a:fillRef`/`a:effectRef`/`a:fontRef`). Returns the
+   * full child object so it can be round-tripped at save time, preserving
+   * any contained colour transforms (`a:lumMod`, `a:tint`, etc.).
+   */
+  extractRefColorXml(refNode) {
+    if (!refNode) {
+      return void 0;
+    }
+    for (const key of COLOR_CHOICE_KEYS2) {
+      const child = refNode[key];
+      if (child !== void 0) {
+        return { [key]: child };
+      }
+    }
+    return void 0;
+  }
   /**
    * Resolve a `a:effectRef` element into concrete effect properties
    * by looking up `@_idx` in the theme format scheme's effect style list.
    */
   resolveThemeEffectRef(refNode, style) {
     const idx = parseInt(String(refNode["@_idx"] || "0"), 10);
+    if (Number.isFinite(idx) && idx > 0) {
+      style.effectRefIdx = idx;
+    }
+    const overrideColorXml = this.extractRefColorXml(refNode);
+    if (overrideColorXml) {
+      style.effectRefColorXml = overrideColorXml;
+    }
     if (!Number.isFinite(idx) || idx <= 0 || !this.themeFormatScheme || idx > this.themeFormatScheme.effectStyles.length) {
       return;
     }
@@ -36083,6 +38182,13 @@ var PptxHandlerRuntime58 = class extends PptxHandlerRuntime57 {
   resolveThemeLineRef(refNode, style) {
     const idx = parseInt(String(refNode["@_idx"] || "0"), 10);
     const overrideColor = this.parseColor(refNode);
+    if (Number.isFinite(idx) && idx > 0) {
+      style.lnRefIdx = idx;
+    }
+    const overrideColorXml = this.extractRefColorXml(refNode);
+    if (overrideColorXml) {
+      style.lnRefColorXml = overrideColorXml;
+    }
     if (!Number.isFinite(idx) || idx <= 0 || !this.themeFormatScheme || idx > this.themeFormatScheme.lineStyles.length) {
       style.strokeColor = overrideColor;
       if (overrideColor) {
@@ -36154,6 +38260,13 @@ var PptxHandlerRuntime58 = class extends PptxHandlerRuntime57 {
    */
   resolveThemeFillRef(refNode, style) {
     const idx = parseInt(String(refNode["@_idx"] || "0"), 10);
+    if (Number.isFinite(idx) && idx > 0) {
+      style.fillRefIdx = idx;
+    }
+    const overrideColorXml = this.extractRefColorXml(refNode);
+    if (overrideColorXml) {
+      style.fillRefColorXml = overrideColorXml;
+    }
     if (!Number.isFinite(idx) || idx <= 0 || !this.themeFormatScheme) {
       style.fillMode = "theme";
       style.fillColor = this.parseColor(refNode);
@@ -36219,7 +38332,7 @@ var PptxHandlerRuntime58 = class extends PptxHandlerRuntime57 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeThemeLoading.ts
-var PptxHandlerRuntime59 = class extends PptxHandlerRuntime58 {
+var PptxHandlerRuntime60 = class extends PptxHandlerRuntime59 {
   async resolvePrimaryThemePath() {
     const masterFiles = this.zip.file(/^ppt\/slideMasters\/slideMaster\d+\.xml$/);
     if (!masterFiles || masterFiles.length === 0) {
@@ -36329,62 +38442,97 @@ var PptxHandlerRuntime59 = class extends PptxHandlerRuntime58 {
       formatScheme: this.themeFormatScheme
     };
   }
-  async applySlideMasterColorMap(defaultMap) {
+  /**
+   * Parse every slide master's `<p:clrMap>` element and store the alias
+   * dictionaries on {@link masterClrMaps}. Do *not* mutate
+   * {@link themeColorMap} — alias resolution happens at colour-lookup
+   * time so that:
+   *
+   * 1. The raw theme scheme stays the source of truth (clrMap is a
+   *    routing layer, not a colour table).
+   * 2. Multi-master decks resolve each slide against its own master's
+   *    clrMap rather than always against `masterFiles[0]`.
+   * 3. Layout `clrMapOvr` semantics work correctly when a slide's master
+   *    differs from the deck's first master.
+   *
+   * Phase 2 Stream B / C-H4.
+   */
+  async applySlideMasterColorMap(_defaultMap) {
     const masterFiles = this.zip.file(/^ppt\/slideMasters\/slideMaster\d+\.xml$/);
     if (!masterFiles || masterFiles.length === 0) {
       return;
     }
-    try {
-      const masterXml = await masterFiles[0].async("string");
-      const masterData = this.parser.parse(masterXml);
-      const clrMap = masterData?.["p:sldMaster"]?.["p:clrMap"];
-      if (!clrMap) {
-        return;
-      }
-      const aliasKeys = [
-        "bg1",
-        "tx1",
-        "bg2",
-        "tx2",
-        "accent1",
-        "accent2",
-        "accent3",
-        "accent4",
-        "accent5",
-        "accent6",
-        "hlink",
-        "folHlink"
-      ];
-      for (const aliasKey of aliasKeys) {
-        const mappedKey = String(clrMap[`@_${aliasKey}`] || "").trim().toLowerCase();
-        if (!mappedKey) {
+    const aliasKeys = [
+      "bg1",
+      "tx1",
+      "bg2",
+      "tx2",
+      "accent1",
+      "accent2",
+      "accent3",
+      "accent4",
+      "accent5",
+      "accent6",
+      "hlink",
+      "folHlink"
+    ];
+    for (const file of masterFiles) {
+      try {
+        const masterXml = await file.async("string");
+        const masterData = this.parser.parse(masterXml);
+        const clrMap = masterData?.["p:sldMaster"]?.["p:clrMap"];
+        if (!clrMap) {
           continue;
         }
-        const mappedColor = this.themeColorMap[mappedKey] || defaultMap[mappedKey];
-        if (mappedColor) {
-          this.themeColorMap[aliasKey] = mappedColor;
+        const aliasMap = {};
+        for (const aliasKey of aliasKeys) {
+          const mappedKey = String(clrMap[`@_${aliasKey}`] || "").trim().toLowerCase();
+          if (mappedKey) {
+            aliasMap[aliasKey] = mappedKey;
+          }
+        }
+        if (Object.keys(aliasMap).length > 0) {
+          this.masterClrMaps.set(file.name, aliasMap);
         }
+      } catch (error) {
+        console.warn(`Failed to parse slide master color map for ${file.name}:`, error);
       }
-    } catch (error) {
-      console.warn("Failed to parse slide master color map:", error);
     }
   }
-  async loadThemeData() {
-    const themeFiles = this.zip.file(/^ppt\/theme\/theme\d+\.xml$/);
-    if (!themeFiles || themeFiles.length === 0) {
-      return;
+  /**
+   * Parse a single theme part into structured colour, font, and format
+   * scheme dictionaries. Used both for the global default theme and for
+   * each master's per-master theme (multi-master support).
+   *
+   * Phase 2 Stream B / C-H4.
+   */
+  async parseThemePart(themePath) {
+    const themeFile = this.zip.file(themePath);
+    if (!themeFile) {
+      return null;
     }
-    const preferredThemePath = await this.resolvePrimaryThemePath();
-    const preferredThemeFile = preferredThemePath ? themeFiles.find((file) => file.name === preferredThemePath) : void 0;
-    const themeFile = preferredThemeFile ?? themeFiles[0];
     const themeXml2 = await themeFile.async("string");
+    this.originalThemeXmlByPath.set(themePath, themeXml2);
     const themeData = this.parser.parse(themeXml2);
     const themeRoot = themeData["a:theme"];
     const themeElements = themeRoot?.["a:themeElements"];
     const colorScheme = themeElements?.["a:clrScheme"];
     const fontScheme = themeElements?.["a:fontScheme"];
+    const fmtScheme = themeElements?.["a:fmtScheme"];
+    const themeName = String(themeRoot?.["@_name"] || "").trim();
+    if (themeName) {
+      this.masterThemeNames.set(themePath, themeName);
+    }
+    const colorSchemeName = String(colorScheme?.["@_name"] || "").trim();
+    if (colorSchemeName) {
+      this.masterThemeColorSchemeNames.set(themePath, colorSchemeName);
+    }
+    const fontSchemeName = String(fontScheme?.["@_name"] || "").trim();
+    if (fontSchemeName) {
+      this.masterThemeFontSchemeNames.set(themePath, fontSchemeName);
+    }
     const defaultMap = this.getDefaultSchemeColorMap();
-    this.themeColorMap = { ...defaultMap };
+    const colorMap = { ...defaultMap };
     if (colorScheme) {
       const schemeKeys = [
         "dk1",
@@ -36404,39 +38552,196 @@ var PptxHandlerRuntime59 = class extends PptxHandlerRuntime58 {
         const colorNode = colorScheme[`a:${key}`];
         const parsed = this.parseColorChoice(colorNode);
         if (parsed) {
-          this.themeColorMap[key] = parsed;
+          colorMap[key] = parsed;
         }
       }
     }
-    this.themeColorMap["tx1"] = this.themeColorMap["dk1"] || defaultMap["dk1"];
-    this.themeColorMap["bg1"] = this.themeColorMap["lt1"] || defaultMap["lt1"];
-    this.themeColorMap["tx2"] = this.themeColorMap["dk2"] || defaultMap["dk2"];
-    this.themeColorMap["bg2"] = this.themeColorMap["lt2"] || defaultMap["lt2"];
-    await this.applySlideMasterColorMap(defaultMap);
-    const majorLatin = fontScheme?.["a:majorFont"]?.["a:latin"];
-    const minorLatin = fontScheme?.["a:minorFont"]?.["a:latin"];
+    colorMap["tx1"] = colorMap["dk1"] || defaultMap["dk1"];
+    colorMap["bg1"] = colorMap["lt1"] || defaultMap["lt1"];
+    colorMap["tx2"] = colorMap["dk2"] || defaultMap["dk2"];
+    colorMap["bg2"] = colorMap["lt2"] || defaultMap["lt2"];
+    const majorFontNode = fontScheme?.["a:majorFont"];
+    const minorFontNode = fontScheme?.["a:minorFont"];
+    const majorLatin = majorFontNode?.["a:latin"];
+    const minorLatin = minorFontNode?.["a:latin"];
     const majorFont = this.normalizeTypefaceToken(String(majorLatin?.["@_typeface"] || ""));
     const minorFont = this.normalizeTypefaceToken(String(minorLatin?.["@_typeface"] || ""));
-    this.themeFontMap = {};
+    const fontMap = {};
     if (majorFont) {
-      this.themeFontMap["mj-lt"] = majorFont;
-      this.themeFontMap["mj-ea"] = majorFont;
-      this.themeFontMap["mj-cs"] = majorFont;
+      fontMap["mj-lt"] = majorFont;
+      fontMap["mj-ea"] = majorFont;
+      fontMap["mj-cs"] = majorFont;
     }
     if (minorFont) {
-      this.themeFontMap["mn-lt"] = minorFont;
-      this.themeFontMap["mn-ea"] = minorFont;
-      this.themeFontMap["mn-cs"] = minorFont;
+      fontMap["mn-lt"] = minorFont;
+      fontMap["mn-ea"] = minorFont;
+      fontMap["mn-cs"] = minorFont;
     }
-    const fmtScheme = themeElements?.["a:fmtScheme"];
-    if (fmtScheme) {
-      this.themeFormatScheme = this.parseFormatScheme(fmtScheme);
+    const majorEa = this.normalizeTypefaceToken(
+      String(majorFontNode?.["a:ea"]?.["@_typeface"] || "")
+    );
+    if (majorEa) {
+      fontMap["mj-ea"] = majorEa;
     }
+    const majorCs = this.normalizeTypefaceToken(
+      String(majorFontNode?.["a:cs"]?.["@_typeface"] || "")
+    );
+    if (majorCs) {
+      fontMap["mj-cs"] = majorCs;
+    }
+    const minorEa = this.normalizeTypefaceToken(
+      String(minorFontNode?.["a:ea"]?.["@_typeface"] || "")
+    );
+    if (minorEa) {
+      fontMap["mn-ea"] = minorEa;
+    }
+    const minorCs = this.normalizeTypefaceToken(
+      String(minorFontNode?.["a:cs"]?.["@_typeface"] || "")
+    );
+    if (minorCs) {
+      fontMap["mn-cs"] = minorCs;
+    }
+    const majorScripts = this.collectFontScriptOverrides(majorFontNode);
+    if (Object.keys(majorScripts).length > 0) {
+      this.masterThemeMajorFontScripts.set(themePath, majorScripts);
+    }
+    const minorScripts = this.collectFontScriptOverrides(minorFontNode);
+    if (Object.keys(minorScripts).length > 0) {
+      this.masterThemeMinorFontScripts.set(themePath, minorScripts);
+    }
+    const objectDefaultsNode = themeRoot?.["a:objectDefaults"];
+    if (objectDefaultsNode) {
+      const od = {
+        spDef: objectDefaultsNode["a:spDef"],
+        lnDef: objectDefaultsNode["a:lnDef"],
+        txDef: objectDefaultsNode["a:txDef"]
+      };
+      if (od.spDef !== void 0 || od.lnDef !== void 0 || od.txDef !== void 0) {
+        this.masterThemeObjectDefaults.set(themePath, od);
+      }
+    }
+    const extraClrSchemeLst = themeRoot?.["a:extraClrSchemeLst"];
+    if (extraClrSchemeLst !== void 0) {
+      this.masterThemeExtraClrSchemeLst.set(themePath, extraClrSchemeLst);
+    }
+    const custClrLst = themeRoot?.["a:custClrLst"];
+    if (custClrLst !== void 0) {
+      this.masterThemeCustClrLst.set(themePath, custClrLst);
+    }
+    const themeExtLst = themeRoot?.["a:extLst"];
+    if (themeExtLst !== void 0) {
+      this.masterThemeExtLst.set(themePath, themeExtLst);
+    }
+    const formatScheme = fmtScheme ? this.parseFormatScheme(fmtScheme) : void 0;
+    return { colorMap, fontMap, formatScheme };
+  }
+  /**
+   * Parse `<a:font script="…" typeface="…"/>` children of a major or
+   * minor font node into a `script -> typeface` dictionary.
+   *
+   * fast-xml-parser collapses repeated tags into arrays, so iterate
+   * over the array form regardless of how many siblings are present.
+   *
+   * Phase 4 Stream A / M4.
+   */
+  collectFontScriptOverrides(fontNode) {
+    const overrides = {};
+    if (!fontNode) {
+      return overrides;
+    }
+    const fontEntries = this.ensureArray(fontNode["a:font"]);
+    for (const entry of fontEntries) {
+      const script = String(entry?.["@_script"] || "").trim();
+      const typeface = this.normalizeTypefaceToken(String(entry?.["@_typeface"] || ""));
+      if (script && typeface) {
+        overrides[script] = typeface;
+      }
+    }
+    return overrides;
+  }
+  /**
+   * Resolve the theme file path referenced by a given master's `.rels`.
+   * Returns `undefined` when the master has no theme relationship.
+   */
+  async resolveThemePathForMaster(masterPath) {
+    const relsPath = masterPath.replace(
+      /ppt\/slideMasters\/(slideMaster\d+)\.xml/,
+      "ppt/slideMasters/_rels/$1.xml.rels"
+    );
+    const relsXml = this.zip.file(relsPath);
+    if (!relsXml) {
+      return void 0;
+    }
+    const relsData = this.parser.parse(await relsXml.async("string"));
+    const relNodes = this.ensureArray(relsData?.Relationships?.Relationship);
+    for (const rel of relNodes) {
+      const target = String(rel["@_Target"] || "");
+      if (!target.includes("theme")) {
+        continue;
+      }
+      const themePath = target.startsWith("..") ? this.resolvePath(masterPath.substring(0, masterPath.lastIndexOf("/") + 1), target) : target.startsWith("/") ? target.slice(1) : `ppt/${target.replace(/^\.?\//, "")}`;
+      if (themePath.startsWith("ppt/theme/")) {
+        return themePath;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Populate {@link masterThemeColorMaps}, {@link masterThemeFontMaps},
+   * and {@link masterThemeFormatSchemes} for every slide master in the
+   * deck. Multi-master support — Phase 2 Stream B / C-H4.
+   */
+  async loadPerMasterThemes() {
+    const masterFiles = this.zip.file(/^ppt\/slideMasters\/slideMaster\d+\.xml$/);
+    if (!masterFiles || masterFiles.length === 0) {
+      return;
+    }
+    for (const file of masterFiles) {
+      try {
+        const themePath = await this.resolveThemePathForMaster(file.name);
+        if (!themePath) {
+          continue;
+        }
+        this.masterThemePaths.set(file.name, themePath);
+        const parsed = await this.parseThemePart(themePath);
+        if (!parsed) {
+          continue;
+        }
+        this.masterThemeColorMaps.set(file.name, parsed.colorMap);
+        this.masterThemeFontMaps.set(file.name, parsed.fontMap);
+        if (parsed.formatScheme) {
+          this.masterThemeFormatSchemes.set(file.name, parsed.formatScheme);
+        }
+      } catch (error) {
+        console.warn(`Failed to load per-master theme for ${file.name}:`, error);
+      }
+    }
+  }
+  async loadThemeData() {
+    const themeFiles = this.zip.file(/^ppt\/theme\/theme\d+\.xml$/);
+    if (!themeFiles || themeFiles.length === 0) {
+      return;
+    }
+    const preferredThemePath = await this.resolvePrimaryThemePath();
+    const themeFile = preferredThemePath ? themeFiles.find((file) => file.name === preferredThemePath) ?? themeFiles[0] : themeFiles[0];
+    const parsed = await this.parseThemePart(themeFile.name);
+    if (parsed) {
+      this.themeColorMap = parsed.colorMap;
+      this.themeFontMap = parsed.fontMap;
+      if (parsed.formatScheme) {
+        this.themeFormatScheme = parsed.formatScheme;
+      }
+    }
+    await this.applySlideMasterColorMap(this.getDefaultSchemeColorMap());
+    await this.loadPerMasterThemes();
+    this.globalThemeColorMapSnapshot = { ...this.themeColorMap };
+    this.globalThemeFontMapSnapshot = { ...this.themeFontMap };
+    this.globalThemeFormatSchemeSnapshot = this.themeFormatScheme;
   }
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeThemeProcessing.ts
-var PptxHandlerRuntime60 = class extends PptxHandlerRuntime59 {
+var PptxHandlerRuntime61 = class extends PptxHandlerRuntime60 {
   // ---------------------------------------------------------------------------
   // Theme editing — update colour scheme, font scheme, and name in the zip
   // ---------------------------------------------------------------------------
@@ -36586,7 +38891,7 @@ var PptxHandlerRuntime60 = class extends PptxHandlerRuntime59 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeComments.ts
-var PptxHandlerRuntime61 = class _PptxHandlerRuntime extends PptxHandlerRuntime60 {
+var PptxHandlerRuntime62 = class _PptxHandlerRuntime extends PptxHandlerRuntime61 {
   /**
    * Parse modern threaded comments (PowerPoint 2019+ / Office 365).
    * Modern comments use `p188:cmLst`/`p15:cmLst` roots within
@@ -36819,7 +39124,7 @@ var PptxHandlerRuntime61 = class _PptxHandlerRuntime extends PptxHandlerRuntime6
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeSmartArtXmlUtils.ts
-var PptxHandlerRuntime62 = class extends PptxHandlerRuntime61 {
+var PptxHandlerRuntime63 = class extends PptxHandlerRuntime62 {
   async readXmlPartByRelationshipId(slidePath, relationshipId) {
     const normalizedRelationshipId = String(relationshipId || "").trim();
     if (normalizedRelationshipId.length === 0) {
@@ -36974,7 +39279,7 @@ var PptxHandlerRuntime62 = class extends PptxHandlerRuntime61 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeSmartArtParsing.ts
-var PptxHandlerRuntime63 = class _PptxHandlerRuntime extends PptxHandlerRuntime62 {
+var PptxHandlerRuntime64 = class _PptxHandlerRuntime extends PptxHandlerRuntime63 {
   /**
    * Parse quick style from `ppt/diagrams/quickStyles*.xml`.
    */
@@ -37133,7 +39438,7 @@ var PptxHandlerRuntime63 = class _PptxHandlerRuntime extends PptxHandlerRuntime6
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeSmartArt.ts
-var PptxHandlerRuntime64 = class extends PptxHandlerRuntime63 {
+var PptxHandlerRuntime65 = class _PptxHandlerRuntime extends PptxHandlerRuntime64 {
   async getSmartArtDataForGraphicFrame(slidePath, graphicFrame) {
     const graphicData = this.xmlLookupService.getChildByLocalName(
       this.xmlLookupService.getChildByLocalName(graphicFrame, "graphic"),
@@ -37184,10 +39489,14 @@ var PptxHandlerRuntime64 = class extends PptxHandlerRuntime63 {
     const layoutPart = layoutRelationshipId.length > 0 ? await this.readXmlPartByRelationshipId(slidePath, layoutRelationshipId) : void 0;
     const layoutType = layoutPart?.partPath?.split("/").pop()?.replace(/\.[^.]+$/, "") || void 0;
     const chrome = this.parseSmartArtChrome(dataModel);
-    const drawingRelationshipId = String(relationshipIds["@_r:cs"] || "").trim();
-    const drawingShapes = await this.parseSmartArtDrawingShapes(slidePath, drawingRelationshipId);
     const colorsRelationshipId = String(relationshipIds["@_r:cs"] || "").trim();
     const colorTransform = await this.parseSmartArtColorTransform(slidePath, colorsRelationshipId);
+    const drawingResolution = await this.resolveSmartArtDrawingPart(
+      slidePath,
+      diagramDataRelationshipId
+    );
+    const drawingShapes = drawingResolution ? await this.parseSmartArtDrawingShapesFromPath(drawingResolution.path) : [];
+    const drawingRelationshipId = drawingResolution?.relId;
     const styleRelationshipId = String(relationshipIds["@_r:qs"] || "").trim();
     const quickStyle = await this.parseSmartArtQuickStyle(slidePath, styleRelationshipId);
     return {
@@ -37199,11 +39508,87 @@ var PptxHandlerRuntime64 = class extends PptxHandlerRuntime63 {
       colorTransform,
       quickStyle,
       dataRelId: diagramDataRelationshipId,
-      drawingRelId: drawingRelationshipId.length > 0 ? drawingRelationshipId : void 0,
+      drawingRelId: drawingRelationshipId && drawingRelationshipId.length > 0 ? drawingRelationshipId : void 0,
       colorsRelId: colorsRelationshipId.length > 0 ? colorsRelationshipId : void 0,
       styleRelId: styleRelationshipId.length > 0 ? styleRelationshipId : void 0
     };
   }
+  /**
+   * Resolve the SmartArt drawing-shapes part path + relationship id.
+   *
+   * Strategy:
+   *  1. Locate the data-model part's rels file
+   *     (`ppt/diagrams/_rels/data*.xml.rels`) via `slideRelsMap`.
+   *  2. Find a relationship whose `Type` matches the `…/diagramDrawing`
+   *     URI. PowerPoint emits this for any deck that has had its
+   *     SmartArt rendered to drawing shapes.
+   *  3. Return the matched part path (so the caller can load it
+   *     directly) and the relationship id (for round-trip preservation).
+   */
+  async resolveSmartArtDrawingPart(slidePath, diagramDataRelationshipId) {
+    if (diagramDataRelationshipId.length === 0) {
+      return void 0;
+    }
+    const slideRels = this.slideRelsMap.get(slidePath);
+    const dataTarget = slideRels?.get(diagramDataRelationshipId);
+    if (!dataTarget) {
+      return void 0;
+    }
+    const dataPath = this.resolveImagePath(slidePath, dataTarget);
+    const dataDir = dataPath.replace(/\/[^/]+$/, "");
+    const dataFile = dataPath.split("/").pop() ?? "";
+    const dataRelsPath = `${dataDir}/_rels/${dataFile}.rels`;
+    const relsXml = await this.zip.file(dataRelsPath)?.async("string");
+    if (!relsXml) {
+      return void 0;
+    }
+    try {
+      const parsed = this.parser.parse(relsXml);
+      const relsRoot = parsed["Relationships"];
+      if (!relsRoot) {
+        return void 0;
+      }
+      const rels = this.ensureArray(relsRoot["Relationship"]);
+      const drawingRel = rels.find(
+        (rel) => String(rel?.["@_Type"] || "").endsWith("/diagramDrawing")
+      );
+      const id = String(drawingRel?.["@_Id"] || "").trim();
+      const target = String(drawingRel?.["@_Target"] || "").trim();
+      if (id.length === 0 || target.length === 0) {
+        return void 0;
+      }
+      const drawingPath = this.resolveImagePath(dataPath, target);
+      return { relId: id, path: drawingPath };
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Parse SmartArt drawing shapes given an absolute part path.
+   *
+   * Wraps `parseSmartArtDrawingShapes` (which expects a slide-relative
+   * relationship id) with a path-based lookup so the resolution layer
+   * can pull the part from anywhere in the package.
+   */
+  async parseSmartArtDrawingShapesFromPath(drawingPath) {
+    const xmlString = await this.zip.file(drawingPath)?.async("string");
+    if (!xmlString) {
+      return [];
+    }
+    try {
+      const xml = this.parser.parse(xmlString);
+      const drawing = this.xmlLookupService.getChildByLocalName(xml, "drawing");
+      const spTree = this.xmlLookupService.getChildByLocalName(drawing || xml, "spTree");
+      if (!spTree) {
+        return [];
+      }
+      const shapes = this.xmlLookupService.getChildrenArrayByLocalName(spTree, "sp");
+      const emuPerPx = _PptxHandlerRuntime.EMU_PER_PX;
+      return shapes.map((sp, index) => this.parseDrawingShape(sp, index, emuPerPx)).filter((entry) => entry !== null);
+    } catch {
+      return [];
+    }
+  }
   parseSmartArtConnections(dataModel) {
     const connectionList = this.xmlLookupService.getChildByLocalName(dataModel, "cxnLst");
     const rawConnections = this.xmlLookupService.getChildrenArrayByLocalName(connectionList, "cxn");
@@ -37234,7 +39619,7 @@ var PptxHandlerRuntime64 = class extends PptxHandlerRuntime63 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeChartDetection.ts
-var PptxHandlerRuntime65 = class extends PptxHandlerRuntime64 {
+var PptxHandlerRuntime66 = class extends PptxHandlerRuntime65 {
   detectChartType(plotArea) {
     if (!plotArea) {
       return "unknown";
@@ -37343,7 +39728,7 @@ var PptxHandlerRuntime65 = class extends PptxHandlerRuntime64 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeChartParsingHelpers.ts
-var PptxHandlerRuntime66 = class extends PptxHandlerRuntime65 {
+var PptxHandlerRuntime67 = class extends PptxHandlerRuntime66 {
   /**
    * Parse `c:plotVisOnly` from the chart root element.
    *
@@ -37404,7 +39789,7 @@ var PptxHandlerRuntime66 = class extends PptxHandlerRuntime65 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeChartExternalData.ts
-var PptxHandlerRuntime67 = class extends PptxHandlerRuntime66 {
+var PptxHandlerRuntime68 = class extends PptxHandlerRuntime67 {
   /**
    * Parse `c:externalData` from the chart's `c:chartSpace` and resolve
    * the external relationship target from the chart part's .rels file.
@@ -37520,7 +39905,7 @@ var PptxHandlerRuntime67 = class extends PptxHandlerRuntime66 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeChartColorStyle.ts
-var PptxHandlerRuntime68 = class extends PptxHandlerRuntime67 {
+var PptxHandlerRuntime69 = class extends PptxHandlerRuntime68 {
   /**
    * Parse the Office 2013+ chart color style part (`chartColorStyle*.xml`)
    * referenced from the chart's relationships.
@@ -37627,7 +40012,7 @@ var PptxHandlerRuntime68 = class extends PptxHandlerRuntime67 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeChartParsing.ts
-var PptxHandlerRuntime69 = class extends PptxHandlerRuntime68 {
+var PptxHandlerRuntime70 = class extends PptxHandlerRuntime69 {
   /**
    * Parse chart data from a graphic frame element on a slide.
    *
@@ -37874,7 +40259,7 @@ var PptxHandlerRuntime69 = class extends PptxHandlerRuntime68 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimePresentationStructure.ts
-var PptxHandlerRuntime70 = class extends PptxHandlerRuntime69 {
+var PptxHandlerRuntime71 = class extends PptxHandlerRuntime70 {
   parseEditorAnimations(slideXml2) {
     return this.editorAnimationService.parseEditorAnimations(slideXml2);
   }
@@ -38119,7 +40504,7 @@ var PptxHandlerRuntime70 = class extends PptxHandlerRuntime69 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeEmbeddedFonts.ts
-var PptxHandlerRuntime71 = class extends PptxHandlerRuntime70 {
+var PptxHandlerRuntime72 = class extends PptxHandlerRuntime71 {
   async getEmbeddedFonts() {
     const embeddedFontEntries = this.ensureArray(
       this.presentationData?.["p:presentation"]?.["p:embeddedFontLst"]?.["p:embeddedFont"]
@@ -38291,7 +40676,7 @@ var PptxHandlerRuntime71 = class extends PptxHandlerRuntime70 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeLoadSession.ts
-var PptxHandlerRuntime72 = class _PptxHandlerRuntime extends PptxHandlerRuntime71 {
+var PptxHandlerRuntime73 = class _PptxHandlerRuntime extends PptxHandlerRuntime72 {
   isZipContainer(data) {
     const bytes = new Uint8Array(data);
     if (bytes.byteLength < 4) {
@@ -38334,6 +40719,23 @@ var PptxHandlerRuntime72 = class _PptxHandlerRuntime extends PptxHandlerRuntime7
     this.imageDataCache.clear();
     this.themeColorMap = {};
     this.themeFontMap = {};
+    this.masterClrMaps.clear();
+    this.masterThemeColorMaps.clear();
+    this.masterThemeFontMaps.clear();
+    this.masterThemeFormatSchemes.clear();
+    this.masterThemePaths.clear();
+    this.masterThemeMajorFontScripts.clear();
+    this.masterThemeMinorFontScripts.clear();
+    this.masterThemeNames.clear();
+    this.masterThemeFontSchemeNames.clear();
+    this.masterThemeColorSchemeNames.clear();
+    this.originalThemeXmlByPath.clear();
+    this.dirtyThemePaths.clear();
+    this.masterThemeObjectDefaults.clear();
+    this.masterThemeExtraClrSchemeLst.clear();
+    this.masterThemeCustClrLst.clear();
+    this.masterThemeExtLst.clear();
+    this.currentMasterClrMap = null;
     this.presentationDefaultTextStyle = void 0;
     this.commentAuthorMap.clear();
     this.commentAuthorDetails.clear();
@@ -38488,6 +40890,7 @@ var PptxHandlerRuntime72 = class _PptxHandlerRuntime extends PptxHandlerRuntime7
       setCurrentSlideClrMapOverride: (override) => {
         this.currentSlideClrMapOverride = override;
       },
+      setActiveMasterForSlide: (slidePath) => this.setActiveMasterForSlide(slidePath),
       findLayoutPathForSlide: (slidePath) => this.findLayoutPathForSlide(slidePath),
       loadThemeOverride: (partBasePath) => this.loadThemeOverride(partBasePath),
       applyThemeOverrideState: (override) => this.applyThemeOverrideState(override),
@@ -38518,7 +40921,7 @@ var PptxHandlerRuntime72 = class _PptxHandlerRuntime extends PptxHandlerRuntime7
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeLoadPipeline.ts
-var PptxHandlerRuntime73 = class extends PptxHandlerRuntime72 {
+var PptxHandlerRuntime74 = class extends PptxHandlerRuntime73 {
   async buildLoadData(presentationState, slidesWithWarnings) {
     const headerFooter = this.extractHeaderFooter();
     const presentationProperties = await this.parsePresentationProperties();
@@ -38530,6 +40933,7 @@ var PptxHandlerRuntime73 = class extends PptxHandlerRuntime72 {
     const notesMaster = await this.parseNotesMaster();
     const handoutMaster = await this.parseHandoutMaster();
     const slideMasters = await this.parseSlideMasters();
+    await this.enrichSlideMastersWithTxStyles(slideMasters);
     const tags = await this.parseTags();
     const customProperties = await this.parseCustomProperties();
     const coreProperties = await this.parseCoreProperties();
@@ -38864,7 +41268,7 @@ var PptxHandlerRuntime73 = class extends PptxHandlerRuntime72 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeImplementation.ts
-var PptxHandlerRuntime74 = class _PptxHandlerRuntime extends PptxHandlerRuntime73 {
+var PptxHandlerRuntime75 = class _PptxHandlerRuntime extends PptxHandlerRuntime74 {
   constructor(dependencyFactory = new PptxRuntimeDependencyFactory()) {
     super();
     this.dependencyFactory = dependencyFactory;
@@ -38912,6 +41316,9 @@ var PptxHandlerRuntime74 = class _PptxHandlerRuntime extends PptxHandlerRuntime7
       extractGradientPathType: (gradFill) => this.colorStyleCodec.extractGradientPathType(gradFill),
       extractGradientFocalPoint: (gradFill) => this.colorStyleCodec.extractGradientFocalPoint(gradFill),
       extractGradientFillToRect: (gradFill) => this.colorStyleCodec.extractGradientFillToRect(gradFill),
+      extractGradientFlip: (gradFill) => this.colorStyleCodec.extractGradientFlip(gradFill),
+      extractGradientRotWithShape: (gradFill) => this.colorStyleCodec.extractGradientRotWithShape(gradFill),
+      extractGradientScaled: (gradFill) => this.colorStyleCodec.extractGradientScaled(gradFill),
       normalizeStrokeDashType: (value) => this.normalizeStrokeDashType(value),
       normalizeConnectorArrowType: (value) => this.normalizeConnectorArrowType(value),
       ensureArray: (value) => this.ensureArray(value),
@@ -38985,11 +41392,11 @@ var PptxHandlerRuntime74 = class _PptxHandlerRuntime extends PptxHandlerRuntime7
 };
 
 // src/core/core/PptxHandlerRuntime.ts
-var PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
+var PptxHandlerRuntime76 = class extends PptxHandlerRuntime75 {
 };
 
 // src/core/core/PptxHandlerRuntimeFactory.ts
-var createDefaultPptxHandlerRuntime = () => new PptxHandlerRuntime75();
+var createDefaultPptxHandlerRuntime = () => new PptxHandlerRuntime76();
 
 // src/core/PptxHandlerCore.ts
 var PptxHandlerCore = class {