node-pptx-templater 2.0.0-alpha.0 → 2.0.0-alpha.2

package/src/managers/SlideManager.js

@@ -28,13 +28,20 @@ const { createLogger } = require('../utils/logger.js')
 const { PPTXError, SlideNotFoundError } = require('../utils/errors.js')
 const { REL_TYPES } = require('./RelationshipManager.js')
 const { buildNewSlideXml } = require('../templates/slideTemplate.js')
-const { remapRelationshipIds } = require('../utils/relationshipUtils.js')
+const { remapRelationshipIds, generateRelationshipId } = require('../utils/relationshipUtils.js')
+const { generateSlideId } = require('../utils/idUtils.js')
 
 const logger = createLogger('SlideManager')
 
 /** MIME type for PPTX slide parts. */
 const SLIDE_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.presentationml.slide+xml'
 
+const CHART_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.drawingml.chart+xml'
+const CHART_STYLE_CONTENT_TYPE = 'application/vnd.ms-office.chartstyle+xml'
+const CHART_COLORS_CONTENT_TYPE = 'application/vnd.ms-office.chartcolorstyle+xml'
+const WORKBOOK_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+const ACTIVEX_CONTENT_TYPE = 'application/vnd.ms-office.activeX'
+
 /**
  * @typedef {Object} SlideInfo
  * @property {number} index - 1-based slide number.
@@ -89,6 +96,12 @@ class SlideManager {
    */
   #presentationObj = null
 
+  /**
+   * Map of old presentation relationship IDs to new sequential IDs.
+   * @private @type {Map<string, string>}
+   */
+  #presentationIdMap = null
+
   /**
    * @param {XMLParser} xmlParser
    * @param {RelationshipManager} relationshipManager
@@ -265,6 +278,14 @@ class SlideManager {
       state.dirty = false
     }
 
+    const dirtyContent = this.#zipManager.readCachedFile(info.zipPath)
+    if (dirtyContent && dirtyContent !== state.xmlStr) {
+      state.xmlStr = dirtyContent
+      this.#slideXmlCache.set(info.zipPath, dirtyContent)
+      state.xmlObj = null
+      state.indexBuilt = false
+    }
+
     if (state.xmlStr) {
       return state.xmlStr
     }
@@ -291,6 +312,14 @@ class SlideManager {
     const info = this.#slides.get(slideIndex)
     const state = this.#slideStates.get(slideIndex)
 
+    const dirtyContent = this.#zipManager.readCachedFile(info.zipPath)
+    if (dirtyContent && dirtyContent !== state.xmlStr) {
+      state.xmlStr = dirtyContent
+      this.#slideXmlCache.set(info.zipPath, dirtyContent)
+      state.xmlObj = null
+      state.indexBuilt = false
+    }
+
     if (!state.xmlStr) {
       const xml = await this.#zipManager.readFile(info.zipPath)
       if (!xml) throw new SlideNotFoundError(`Slide ${slideIndex} XML not found at ${info.zipPath}`)
@@ -389,9 +418,8 @@ class SlideManager {
     relationshipManager.addRelationship(slideZipPath, REL_TYPES.SLIDE_LAYOUT, relativeLayoutPath)
 
     // Generate a unique slide ID
-    const existingIds = Array.from(this.#slides.values()).map(s => parseInt(s.slideId, 10))
-    const maxId = existingIds.length > 0 ? Math.max(...existingIds) : 255
-    const newSlideId = String(maxId + 1)
+    const existingSlideIds = Array.from(this.#slides.values()).map(s => s.slideId)
+    const newSlideId = generateSlideId(existingSlideIds)
 
     const slideInfo = {
       index: newIndex,
@@ -429,8 +457,24 @@ class SlideManager {
    * @param {number} sourceIndex - 1-based source slide number.
    * @param {number} [atPosition] - Insert position (1-based). Default: append.
    * @param {RelationshipManager} relationshipManager
+   * @param {MediaManager} mediaManager
+   * @returns {Promise<void>}
+   */
+  async cloneSlide(sourceIndex, atPosition, relationshipManager, mediaManager) {
+    const promise = this.#cloneSlideInternal(
+      sourceIndex,
+      atPosition,
+      relationshipManager,
+      mediaManager
+    )
+    this.#zipManager.addPendingPromise(promise)
+    return promise
+  }
+
+  /**
+   * @private
    */
-  cloneSlide(sourceIndex, atPosition, relationshipManager) {
+  async #cloneSlideInternal(sourceIndex, atPosition, relationshipManager, mediaManager) {
     this.#assertSlideExists(sourceIndex)
     const sourceInfo = this.#slides.get(sourceIndex)
     logger.debug('Source Slide Info:', sourceInfo)
@@ -443,26 +487,90 @@ class SlideManager {
     const slideFileName = `slide${nextFileIndex}.xml`
     const slideZipPath = `ppt/slides/${slideFileName}`
 
-    // Copy the source XML
-    let sourceXml = this.getSlideXml(sourceIndex)
-    logger.debug('Source XML length:', sourceXml ? sourceXml.length : 0)
+    // Snapshot source XML — never mutate the original slide content
+    const sourceXmlSnapshot = this.getSlideXml(sourceIndex)
+    logger.debug('Source XML length:', sourceXmlSnapshot ? sourceXmlSnapshot.length : 0)
 
-    // Copy relationships
     const sourceRels = relationshipManager.getRelationships(sourceInfo.zipPath)
     logger.debug('Source Rels Path searched:', relationshipManager.getRelsPath(sourceInfo.zipPath))
     logger.debug('Source Rels found:', sourceRels)
 
-    // Copy relationships from source slide (excluding notes, which are slide-specific)
-    const idMap = relationshipManager.copyRelationships(sourceInfo.zipPath, slideZipPath, [
-      REL_TYPES.NOTES_SLIDE,
-    ])
-    logger.debug('Copied relationship ID map:', Array.from(idMap.entries()))
+    const idMap = await this.#deepCloneSlideRelationships(
+      sourceInfo.zipPath,
+      slideZipPath,
+      relationshipManager,
+      mediaManager,
+      sourceRels,
+      [REL_TYPES.NOTES_SLIDE]
+    )
+    logger.debug('Deep-cloned relationship ID map:', Array.from(idMap.entries()))
+
+    let cloneXml = remapRelationshipIds(sourceXmlSnapshot, idMap)
+    cloneXml = this.#regenerateTableRowIds(cloneXml)
 
-    // Remap relationship IDs in the cloned XML to match the new targets
-    sourceXml = remapRelationshipIds(sourceXml, idMap)
+    this.#zipManager.writeFile(slideZipPath, cloneXml)
+    this.#slideXmlCache.set(slideZipPath, cloneXml)
 
-    this.#zipManager.writeFile(slideZipPath, sourceXml)
-    this.#slideXmlCache.set(slideZipPath, sourceXml)
+    // Clone notes slide if source slide has one
+    const notesRel = sourceRels.find(r => r.type === REL_TYPES.NOTES_SLIDE)
+    if (notesRel) {
+      const sourceNotesPath = relationshipManager.resolveTarget(sourceInfo.zipPath, notesRel.target)
+      let notesXml = this.#zipManager.readCachedFile(sourceNotesPath)
+      if (!notesXml) {
+        notesXml = await this.#zipManager.readFile(sourceNotesPath)
+      }
+
+      if (notesXml) {
+        let nextNotesIndex = 1
+        while (this.#zipManager.hasFile(`ppt/notesSlides/notesSlide${nextNotesIndex}.xml`)) {
+          nextNotesIndex++
+        }
+        const notesFileName = `notesSlide${nextNotesIndex}.xml`
+        const notesZipPath = `ppt/notesSlides/${notesFileName}`
+
+        // Deep-clone relationships from source notes slide (so slide-specific resources like tags are also copied)
+        const sourceNotesRels = relationshipManager.getRelationships(sourceNotesPath)
+        const notesIdMap = await this.#deepCloneSlideRelationships(
+          sourceNotesPath,
+          notesZipPath,
+          relationshipManager,
+          mediaManager,
+          sourceNotesRels
+        )
+
+        // Update target in notes relationships to point back to the new slide
+        // IMPORTANT: patch the back-reference BEFORE flushing to ZIP so the
+        // .rels file on disk contains the correct slide path.
+        const notesRels = relationshipManager.getRelationships(notesZipPath)
+        const slideRel = notesRels.find(
+          r => r.type === REL_TYPES.SLIDE || r.type.endsWith('/slide')
+        )
+        if (slideRel) {
+          slideRel.target = `../slides/${slideFileName}`
+        }
+        // Flush AFTER the target is patched so the written .rels is correct
+        relationshipManager.flushRelationships(notesZipPath)
+
+        // Remap relationship IDs in notes XML
+        notesXml = remapRelationshipIds(notesXml, notesIdMap)
+
+        // Write the notes slide XML to ZIP
+        this.#zipManager.writeFile(notesZipPath, notesXml)
+
+        // Add content type override
+        this.#contentTypesManager.addOverride(
+          notesZipPath,
+          'application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml'
+        )
+
+        // Add notes slide relationship to the new slide
+        relationshipManager.addRelationship(
+          slideZipPath,
+          REL_TYPES.NOTES_SLIDE,
+          `../notesSlides/${notesFileName}`
+        )
+      }
+    }
 
     // Add to presentation.xml
     const rId = relationshipManager.addRelationship(
@@ -471,9 +579,8 @@ class SlideManager {
       `slides/${slideFileName}`
     )
 
-    const existingIds = Array.from(this.#slides.values()).map(s => parseInt(s.slideId, 10))
-    const maxId = Math.max(...existingIds)
-    const newSlideId = String(maxId + 1)
+    const existingSlideIds = Array.from(this.#slides.values()).map(s => s.slideId)
+    const newSlideId = generateSlideId(existingSlideIds)
 
     const slideInfo = {
       index: newIndex,
@@ -486,7 +593,7 @@ class SlideManager {
 
     this.#slides.set(newIndex, slideInfo)
     this.#slideStates.set(newIndex, {
-      xmlStr: sourceXml,
+      xmlStr: cloneXml,
       xmlObj: null,
       dirty: false,
       indexBuilt: false,
@@ -501,6 +608,401 @@ class SlideManager {
     logger.debug(`Cloned slide ${sourceIndex} to new slide ${newIndex}`)
   }
 
+  /**
+   * Deep-clones slide relationships so every embedded part (chart, image, VML drawing,
+   * SmartArt, custom XML, audio/video, etc.) gets its own independent copy.
+   * Shared presentation-level resources (layout, master, theme, tableStyles) are reused.
+   *
+   * IMPORTANT: Every internal part that is unique to a slide MUST be deep-copied here.
+   * Sharing mutable internal parts between slides causes PowerPoint corruption, particularly
+   * in enterprise environments with strict validators (e.g. Boldon James Classifier).
+   * @private
+   */
+  async #deepCloneSlideRelationships(
+    sourcePath,
+    destPath,
+    relationshipManager,
+    mediaManager,
+    sourceRels,
+    excludeTypes = []
+  ) {
+    const idMap = new Map()
+    const destRels = []
+
+    for (const rel of sourceRels) {
+      if (excludeTypes.includes(rel.type)) continue
+
+      let target = rel.target
+      const resolvedTarget =
+        rel.targetMode === 'External'
+          ? null
+          : relationshipManager.resolveTarget(sourcePath, rel.target)
+      const typeEnd = rel.type.split('/').pop().toLowerCase()
+
+      if (rel.targetMode === 'External') {
+        // External hyperlinks, audio/video links — reuse as-is
+      } else if (rel.type === REL_TYPES.CHART) {
+        // Charts → deep copy with independent workbook/style/color
+        target = await this.#copyChartPart(resolvedTarget, relationshipManager)
+      } else if (rel.type === REL_TYPES.IMAGE) {
+        // Raster/vector images — copy as new media part
+        const newMediaPath = await mediaManager.copyMediaAsNewPart(resolvedTarget)
+        target = `../media/${newMediaPath.split('/').pop()}`
+      } else if (
+        rel.type === REL_TYPES.SLIDE_LAYOUT ||
+        rel.type === REL_TYPES.SLIDE_MASTER ||
+        rel.type === REL_TYPES.THEME ||
+        rel.type === REL_TYPES.TABLE_STYLES ||
+        rel.type ===
+          'http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster' ||
+        rel.type ===
+          'http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide' ||
+        rel.type === REL_TYPES.SLIDE
+      ) {
+        // Shared presentation-level resources — reuse same target
+      } else if (typeEnd === 'audio' || typeEnd === 'video' || typeEnd === 'media') {
+        // Embedded audio/video binary — copy to new media file
+        if (this.#zipManager.hasFile(resolvedTarget)) {
+          const newPath = await this.#copyBinaryPart(resolvedTarget)
+          if (newPath) target = this.#makeRelativeTarget(destPath, newPath)
+        }
+      } else if (typeEnd === 'vmldrawing') {
+        // VML drawings (legacy shapes, comment boxes) — must be independent per slide
+        if (this.#zipManager.hasFile(resolvedTarget)) {
+          const newTarget = await this.#copyGenericXmlPart(
+            resolvedTarget,
+            destPath,
+            relationshipManager
+          )
+          if (newTarget) target = newTarget
+        }
+      } else if (
+        typeEnd === 'diagramdata' ||
+        typeEnd === 'diagramlayout' ||
+        typeEnd === 'diagramquickstyle' ||
+        typeEnd === 'diagramcolors' ||
+        typeEnd === 'diagram'
+      ) {
+        // SmartArt/diagram parts — each slide needs its own copy
+        if (this.#zipManager.hasFile(resolvedTarget)) {
+          const newTarget = await this.#copyGenericXmlPart(
+            resolvedTarget,
+            destPath,
+            relationshipManager
+          )
+          if (newTarget) target = newTarget
+        }
+      } else if (typeEnd === 'oleobject' || typeEnd === 'activex') {
+        // Non-chart OLE / ActiveX objects — copy binary
+        if (this.#zipManager.hasFile(resolvedTarget)) {
+          const newPath = await this.#copyBinaryPart(resolvedTarget)
+          if (newPath) {
+            target = this.#makeRelativeTarget(destPath, newPath)
+          }
+        }
+      } else if (rel.target && !rel.target.startsWith('http') && resolvedTarget) {
+        // Catch-all for any other internal part: copy XML if the file extension is .xml,
+        // otherwise copy as binary. This handles custom XML (e.g. Boldon James classification
+        // parts) and any future unknown relationship types.
+        if (this.#zipManager.hasFile(resolvedTarget)) {
+          if (resolvedTarget.toLowerCase().endsWith('.xml')) {
+            // Text/XML content
+            const newTarget = await this.#copyGenericXmlPart(
+              resolvedTarget,
+              destPath,
+              relationshipManager
+            )
+            if (newTarget) target = newTarget
+          } else {
+            // Binary content
+            const newPath = await this.#copyBinaryPart(resolvedTarget)
+            if (newPath) {
+              target = this.#makeRelativeTarget(destPath, newPath)
+            }
+          }
+        } else {
+          // Part not in ZIP (may be external or already purged) — keep original target
+          logger.warn(`Clone: part not found in ZIP, reusing original target: ${resolvedTarget}`)
+        }
+      }
+
+      const newId = generateRelationshipId(destRels.map(r => r.id))
+      const newRel = { id: newId, type: rel.type, target }
+      if (rel.targetMode) newRel.targetMode = rel.targetMode
+      destRels.push(newRel)
+      idMap.set(rel.id, newId)
+    }
+
+    relationshipManager.setRelationships(destPath, destRels)
+    relationshipManager.flushRelationships(destPath)
+    return idMap
+  }
+
+  /**
+   * Copies a chart part and all of its dependent chart style/color/workbook parts.
+   * @private
+   * @returns {Promise<string>} Relative target for the cloned slide relationship.
+   */
+  async #copyChartPart(sourceChartPath, relationshipManager) {
+    let chartXml = this.#zipManager.readCachedFile(sourceChartPath)
+    if (!chartXml) {
+      chartXml = await this.#zipManager.readFile(sourceChartPath)
+    }
+    if (!chartXml) {
+      throw new PPTXError(`Cannot clone slide: chart not found at ${sourceChartPath}`)
+    }
+
+    const sourceChartRels = relationshipManager.getRelationships(sourceChartPath)
+    let nextChartNum = 1
+    while (this.#zipManager.hasFile(`ppt/charts/chart${nextChartNum}.xml`)) {
+      nextChartNum++
+    }
+    const destChartFileName = `chart${nextChartNum}.xml`
+    const destChartPath = `ppt/charts/${destChartFileName}`
+
+    const destChartRels = []
+    const chartRelIdMap = new Map()
+
+    for (const rel of sourceChartRels) {
+      const resolved = relationshipManager.resolveTarget(sourceChartPath, rel.target)
+      let newTarget = rel.target
+
+      if (rel.type === REL_TYPES.PACKAGE || rel.target.includes('../embeddings/')) {
+        const bytes = await this.#zipManager.readBinaryFile(resolved)
+        if (bytes) {
+          const fileName = resolved.split('/').pop()
+          let nextEmbed = 1
+          let destWorkbookPath = `ppt/embeddings/Microsoft_Excel_Worksheet${nextEmbed}.xlsx`
+          if (fileName.endsWith('.bin')) {
+            destWorkbookPath = `ppt/embeddings/oleObject${nextEmbed}.bin`
+          }
+          while (this.#zipManager.hasFile(destWorkbookPath)) {
+            nextEmbed++
+            destWorkbookPath = fileName.endsWith('.bin')
+              ? `ppt/embeddings/oleObject${nextEmbed}.bin`
+              : `ppt/embeddings/Microsoft_Excel_Worksheet${nextEmbed}.xlsx`
+          }
+          this.#zipManager.writeBinaryFile(destWorkbookPath, bytes)
+          this.#contentTypesManager.addOverride(
+            destWorkbookPath,
+            fileName.endsWith('.bin') ? ACTIVEX_CONTENT_TYPE : WORKBOOK_CONTENT_TYPE
+          )
+          newTarget = `../embeddings/${destWorkbookPath.split('/').pop()}`
+        }
+      } else if (/colors\d+\.xml$/i.test(rel.target)) {
+        newTarget = await this.#copyChartSupportXml(resolved, 'colors', CHART_COLORS_CONTENT_TYPE)
+      } else if (/style\d+\.xml$/i.test(rel.target)) {
+        newTarget = await this.#copyChartSupportXml(resolved, 'style', CHART_STYLE_CONTENT_TYPE)
+      }
+
+      const newId = generateRelationshipId(destChartRels.map(r => r.id))
+      const newRel = { id: newId, type: rel.type, target: newTarget }
+      if (rel.targetMode) newRel.targetMode = rel.targetMode
+      destChartRels.push(newRel)
+      chartRelIdMap.set(rel.id, newId)
+    }
+
+    chartXml = remapRelationshipIds(chartXml, chartRelIdMap)
+    this.#zipManager.writeFile(destChartPath, chartXml)
+    relationshipManager.setRelationships(destChartPath, destChartRels)
+    relationshipManager.flushRelationships(destChartPath)
+    this.#contentTypesManager.addOverride(destChartPath, CHART_CONTENT_TYPE)
+
+    return `../charts/${destChartFileName}`
+  }
+
+  /**
+   * Copies a chart colors/style XML part to a new sequentially numbered file.
+   * @private
+   */
+  async #copyChartSupportXml(sourcePath, prefix, contentType) {
+    let content = this.#zipManager.readCachedFile(sourcePath)
+    if (!content) {
+      content = await this.#zipManager.readFile(sourcePath)
+    }
+    if (!content) return sourcePath.split('/').pop()
+
+    let nextNum = 1
+    let destFileName = `${prefix}${nextNum}.xml`
+    while (this.#zipManager.hasFile(`ppt/charts/${destFileName}`)) {
+      nextNum++
+      destFileName = `${prefix}${nextNum}.xml`
+    }
+    const destPath = `ppt/charts/${destFileName}`
+    this.#zipManager.writeFile(destPath, content)
+    this.#contentTypesManager.addOverride(destPath, contentType)
+    return destFileName
+  }
+
+  /**
+   * Copies a generic XML text part to a new sequentially numbered path in the same
+   * directory as the source. Returns a relative target path from the destination slide,
+   * or null if the copy failed.
+   * @private
+   * @param {string} sourcePath - Absolute ZIP path of the source XML part.
+   * @returns {Promise<string|null>} Relative target for the cloned slide relationship.
+   */
+  async #copyGenericXmlPart(sourcePath, destPath, relationshipManager) {
+    let content = this.#zipManager.readCachedFile(sourcePath)
+    if (!content) {
+      content = await this.#zipManager.readFile(sourcePath)
+    }
+    if (!content) return null
+
+    const parts = sourcePath.split('/')
+    const dir = parts.slice(0, -1).join('/')
+    const fileName = parts[parts.length - 1]
+    // Extract base name and extension: e.g. 'vmlDrawing1.xml' → base='vmlDrawing', ext='xml'
+    const lastDot = fileName.lastIndexOf('.')
+    const ext = lastDot >= 0 ? fileName.slice(lastDot) : ''
+    const base = lastDot >= 0 ? fileName.slice(0, lastDot).replace(/\d+$/, '') : fileName
+
+    let num = 1
+    let destPartPath = `${dir}/${base}${num}${ext}`
+    while (this.#zipManager.hasFile(destPartPath)) {
+      num++
+      destPartPath = `${dir}/${base}${num}${ext}`
+    }
+
+    this.#zipManager.writeFile(destPartPath, content)
+
+    // Mirror content type if one exists for the source
+    const srcContentType = this.#contentTypesManager.getOverrideContentType(sourcePath)
+    if (srcContentType) {
+      this.#contentTypesManager.addOverride(destPartPath, srcContentType)
+    }
+
+    // Clone any relationships/dependencies of this XML part recursively
+    await this.#copyPartDependencies(sourcePath, destPartPath, relationshipManager)
+
+    logger.debug(`Cloned XML part: ${sourcePath} → ${destPartPath}`)
+    return this.#makeRelativeTarget(destPath, destPartPath)
+  }
+
+  /**
+   * Recursively copies relationships and dependency parts for a cloned XML part.
+   * @private
+   * @param {string} sourcePartPath - Absolute ZIP path of the source XML part.
+   * @param {string} destPartPath - Absolute ZIP path of the destination XML part.
+   * @param {RelationshipManager} relationshipManager
+   * @returns {Promise<void>}
+   */
+  async #copyPartDependencies(sourcePartPath, destPartPath, relationshipManager) {
+    const rels = relationshipManager.getRelationships(sourcePartPath)
+    if (!rels || rels.length === 0) return
+
+    // 1. Copy relationships file first (sets up destPath rels list)
+    relationshipManager.copyRelationships(sourcePartPath, destPartPath)
+
+    // 2. Iterate and clone each target part
+    const destRels = relationshipManager.getRelationships(destPartPath)
+    let dirty = false
+
+    for (const rel of destRels) {
+      if (rel.targetMode === 'External' || !rel.target || rel.target.startsWith('http')) continue
+
+      const resolved = relationshipManager.resolveTarget(sourcePartPath, rel.target)
+      if (!this.#zipManager.hasFile(resolved)) continue
+
+      let newTarget = rel.target
+      if (resolved.toLowerCase().endsWith('.xml')) {
+        // XML part - copy recursively
+        newTarget = await this.#copyGenericXmlPart(resolved, destPartPath, relationshipManager)
+      } else {
+        // Binary part
+        const newBinaryPath = await this.#copyBinaryPart(resolved)
+        if (newBinaryPath) {
+          newTarget = this.#makeRelativeTarget(destPartPath, newBinaryPath)
+        }
+      }
+
+      if (newTarget && newTarget !== rel.target) {
+        rel.target = newTarget
+        dirty = true
+      }
+    }
+
+    if (dirty) {
+      relationshipManager.flushRelationships(destPartPath)
+    }
+  }
+
+  /**
+   * Copies a binary part (audio, video, OLE object, etc.) to a new path in the same
+   * directory as the source. Returns the new absolute ZIP path, or null on failure.
+   * @private
+   * @param {string} sourcePath - Absolute ZIP path of the source binary part.
+   * @returns {Promise<string|null>} New absolute ZIP path.
+   */
+  async #copyBinaryPart(sourcePath) {
+    const data = await this.#zipManager.readBinaryFile(sourcePath)
+    if (!data) return null
+
+    const parts = sourcePath.split('/')
+    const dir = parts.slice(0, -1).join('/')
+    const fileName = parts[parts.length - 1]
+    const lastDot = fileName.lastIndexOf('.')
+    const ext = lastDot >= 0 ? fileName.slice(lastDot) : ''
+    const base = lastDot >= 0 ? fileName.slice(0, lastDot).replace(/\d+$/, '') : fileName
+
+    let num = 1
+    let destPath = `${dir}/${base}${num}${ext}`
+    while (this.#zipManager.hasFile(destPath)) {
+      num++
+      destPath = `${dir}/${base}${num}${ext}`
+    }
+
+    this.#zipManager.writeBinaryFile(destPath, data)
+
+    const srcContentType = this.#contentTypesManager.getOverrideContentType(sourcePath)
+    if (srcContentType) {
+      this.#contentTypesManager.addOverride(destPath, srcContentType)
+    }
+
+    logger.debug(`Cloned binary part: ${sourcePath} → ${destPath}`)
+    return destPath
+  }
+
+  /**
+   * Builds a relative target path from a source ZIP part to a destination ZIP path.
+   * @private
+   * @param {string} fromPath - Absolute path of the part containing the relationship.
+   * @param {string} toPath - Absolute ZIP path of the target.
+   * @returns {string} Relative path from fromPath's directory to toPath.
+   */
+  #makeRelativeTarget(fromPath, toPath) {
+    const fromDir = fromPath.split('/').slice(0, -1)
+    const toParts = toPath.split('/')
+    // Find common prefix length
+    let common = 0
+    while (
+      common < fromDir.length &&
+      common < toParts.length - 1 &&
+      fromDir[common] === toParts[common]
+    ) {
+      common++
+    }
+    const ups = fromDir.length - common
+    const downs = toParts.slice(common)
+    return (ups > 0 ? '../'.repeat(ups) : './') + downs.join('/')
+  }
+
+  /**
+   * Assigns fresh a16:rowId values in cloned slide XML so table rows are independent.
+   * @private
+   */
+  #regenerateTableRowIds(xml) {
+    const used = new Set()
+    return xml.replace(/(<a16:rowId[^>]*\sval=")([^"]+)(")/g, (_match, prefix, _oldVal, suffix) => {
+      let newVal
+      do {
+        newVal = String(Math.floor(Math.random() * 0xffffffff))
+      } while (used.has(newVal))
+      used.add(newVal)
+      return `${prefix}${newVal}${suffix}`
+    })
+  }
+
   /**
    * Removes a slide from the presentation.
    *
@@ -510,32 +1012,58 @@ class SlideManager {
     this.#assertSlideExists(slideIndex)
     const info = this.#slides.get(slideIndex)
 
-    // Remove from ZIP
+    // 1. Check for notes slide relationship and remove it first
+    const slideRels = this.#relationshipManager.getRelationships(info.zipPath)
+    const notesRel = slideRels.find(r => r.type === REL_TYPES.NOTES_SLIDE)
+    if (notesRel) {
+      const notesPath = this.#relationshipManager.resolveTarget(info.zipPath, notesRel.target)
+
+      // Remove from ZIP
+      this.#zipManager.removeFile(notesPath)
+
+      // Remove its relationships file — use getRelsPath for robustness
+      const notesRelsPath = this.#relationshipManager.getRelsPath(notesPath)
+      this.#zipManager.removeFile(notesRelsPath)
+
+      // Remove relationships from cache
+      this.#relationshipManager.deleteRelationships(notesPath)
+
+      // Remove content type override
+      this.#contentTypesManager.removeOverride(notesPath)
+    }
+
+    // 2. Remove slide XML from ZIP
     this.#zipManager.removeFile(info.zipPath)
 
-    // Remove its relationships file
-    const relsFileName = info.zipPath.split('/').pop() + '.rels'
-    this.#zipManager.removeFile(`ppt/slides/_rels/${relsFileName}`)
+    // 3. Remove slide .rels file — use getRelsPath so non-standard paths work correctly
+    const slideRelsPath = this.#relationshipManager.getRelsPath(info.zipPath)
+    this.#zipManager.removeFile(slideRelsPath)
 
-    // Remove from cache
+    // 4. Remove slide relationship cache entry
+    this.#relationshipManager.deleteRelationships(info.zipPath)
+
+    // 5. Remove slide XML cache entries
     this.#slideXmlCache.delete(info.zipPath)
     this.#slideStates.delete(slideIndex)
 
-    // Remove relationship from presentation.xml
-    this.#relationshipManager.removeRelationship('ppt/presentation.xml', info.relationshipId)
+    // 6. Remove content type from [Content_Types].xml
+    this.#contentTypesManager.removeOverride(info.zipPath)
 
-    // Remove relationships cache
-    this.#relationshipManager.deleteRelationships(info.zipPath)
+    // 7. Remove relationship from presentation.xml.rels
+    this.#relationshipManager.removeRelationship('ppt/presentation.xml', info.relationshipId)
 
-    // Remove content type from [Content_Types].xml
-    this.#contentTypesManager.removeOverride(info.zipPath)
+    // 8. Remove from presentation.xml sldIdLst and sections BEFORE reindexing.
+    //    This ensures the sldIdLst is consistent with the relationship list.
+    this.#removeSlideFromPresentation(info.slideId)
 
-    // Remove from slides map and reindex
+    // 9. Remove from slides map and reindex remaining slides
     this.#slides.delete(slideIndex)
     this.#reindexSlides()
 
-    // Update presentation.xml
-    this.#removeSlideFromPresentation(info.slideId)
+    // 10. Rebuild sldIdLst and synchronize sections to reflect the updated slide order.
+    //     This is essential: after reindexing, the relationship IDs and slide IDs are
+    //     still valid but the sldIdLst order must be rebuilt so sections match.
+    this.rebuildPresentationSlideOrder()
 
     logger.debug(`Removed slide ${slideIndex}`)
   }
@@ -906,7 +1434,20 @@ class SlideManager {
    * @returns {Promise<void>}
    */
   async preloadAll() {
-    await Promise.all(this.getAllSlideIndices().map(i => this.getSlideXmlAsync(i)))
+    await Promise.all(
+      this.getAllSlideIndices().map(async i => {
+        await this.getSlideXmlAsync(i)
+
+        // Also check and preload notes slide XML
+        const info = this.#slides.get(i)
+        const rels = this.#relationshipManager.getRelationships(info.zipPath)
+        const notesRel = rels.find(r => r.type === REL_TYPES.NOTES_SLIDE)
+        if (notesRel) {
+          const notesPath = this.#relationshipManager.resolveTarget(info.zipPath, notesRel.target)
+          await this.#zipManager.readFile(notesPath)
+        }
+      })
+    )
   }
 
   /**
@@ -991,9 +1532,10 @@ class SlideManager {
     const sldIdLst = this.#xmlParser.getNode(this.#presentationObj, 'p:presentation.p:sldIdLst')
     if (!sldIdLst?.['p:sldId']) return
 
+    const targetIdStr = String(slideId)
     sldIdLst['p:sldId'] = (
       Array.isArray(sldIdLst['p:sldId']) ? sldIdLst['p:sldId'] : [sldIdLst['p:sldId']]
-    ).filter(s => s['@_id'] !== slideId)
+    ).filter(s => String(s['@_id']) !== targetIdStr)
 
     // Also remove from any PowerPoint sections
     this.#removeSlideFromSections(slideId)
@@ -1048,6 +1590,74 @@ class SlideManager {
     })
 
     sldIdLst['p:sldId'] = ordered
+
+    // Synchronize sections order with the new slide order
+    const orderedSlideIds = ordered.map(o => String(o['@_id']))
+    const extLst = this.#xmlParser.getNode(this.#presentationObj, 'p:presentation.p:extLst')
+    if (extLst?.['p:ext']) {
+      const exts = Array.isArray(extLst['p:ext']) ? extLst['p:ext'] : [extLst['p:ext']]
+      for (const ext of exts) {
+        const sectionLst = ext['p14:sectionLst']
+        if (sectionLst?.['p14:section']) {
+          const sections = Array.isArray(sectionLst['p14:section'])
+            ? sectionLst['p14:section']
+            : [sectionLst['p14:section']]
+
+          // 1. Identify section anchors (first slide of each section)
+          const sectionAnchors = []
+          for (const section of sections) {
+            const sldIdLstObj = section['p14:sldIdLst']
+            if (sldIdLstObj?.['p14:sldId']) {
+              const sldIds = Array.isArray(sldIdLstObj['p14:sldId'])
+                ? sldIdLstObj['p14:sldId']
+                : [sldIdLstObj['p14:sldId']]
+              // Find the first valid slide ID in this section that is still present in the ordered list
+              let anchorId = null
+              for (const sldId of sldIds) {
+                if (sldId && sldId['@_id']) {
+                  const idStr = String(sldId['@_id'])
+                  if (orderedSlideIds.includes(idStr)) {
+                    anchorId = idStr
+                    break
+                  }
+                }
+              }
+              sectionAnchors.push({ section, anchorId })
+            } else {
+              sectionAnchors.push({ section, anchorId: null })
+            }
+          }
+
+          // 2. Clear the slide lists of all sections
+          for (const section of sections) {
+            if (!section['p14:sldIdLst']) {
+              section['p14:sldIdLst'] = { 'p14:sldId': [] }
+            } else {
+              section['p14:sldIdLst']['p14:sldId'] = []
+            }
+          }
+
+          // 3. Populate sections by tracing ordered slide IDs and switching sections when an anchor is reached
+          let currentSection = sections[0] || null
+
+          for (const slideId of orderedSlideIds) {
+            // Check if this slideId is the anchor of another section
+            const matchingAnchor = sectionAnchors.find(sa => sa.anchorId === slideId)
+            if (matchingAnchor) {
+              currentSection = matchingAnchor.section
+            }
+
+            if (currentSection) {
+              if (!currentSection['p14:sldIdLst']) {
+                currentSection['p14:sldIdLst'] = { 'p14:sldId': [] }
+              }
+              currentSection['p14:sldIdLst']['p14:sldId'].push({ '@_id': slideId })
+            }
+          }
+        }
+      }
+    }
+
     this.#flushPresentation()
   }
 
@@ -1117,10 +1727,26 @@ class SlideManager {
    * @param {number} slideIndex
    * @param {number} [atPosition]
    * @param {RelationshipManager} relationshipManager
-   * @returns {number}
+   * @param {MediaManager} mediaManager
+   * @returns {Promise<number>}
    */
-  duplicateSlide(slideIndex, atPosition, relationshipManager) {
-    this.cloneSlide(slideIndex, null, relationshipManager)
+  async duplicateSlide(slideIndex, atPosition, relationshipManager, mediaManager) {
+    const promise = this.#duplicateSlideInternal(
+      slideIndex,
+      atPosition,
+      relationshipManager,
+      mediaManager
+    )
+    this.#zipManager.addPendingPromise(promise)
+    return promise
+  }
+
+  /**
+   * Internal duplicate implementation.
+   * @private
+   */
+  async #duplicateSlideInternal(slideIndex, atPosition, relationshipManager, mediaManager) {
+    await this.#cloneSlideInternal(slideIndex, null, relationshipManager, mediaManager)
     const count = this.slideCount
     if (atPosition !== undefined && atPosition !== count) {
       const order = []
@@ -1311,6 +1937,328 @@ class SlideManager {
     }
   }
 
+  /**
+   * Normalizes the slide filenames, slide IDs, and relationship IDs on export.
+   * Ensures slide filenames are strictly sequential (slide1.xml, slide2.xml, ...)
+   * and match their visual order, and updates all relationships and content types.
+   * Also normalizes notes slide filenames to match slide order.
+   *
+   * @param {RelationshipManager} relationshipManager
+   * @param {ContentTypesManager} contentTypesManager
+   */
+  async normalizeStructure(relationshipManager, contentTypesManager) {
+    const slides = this.getAllSlideInfo()
+    if (slides.length === 0) return
+
+    // 1. Map old path -> new path, old filename -> new filename
+    const pathMap = new Map()
+    const nameMap = new Map()
+
+    slides.forEach((info, idx) => {
+      const newPath = `ppt/slides/slide${idx + 1}.xml`
+      pathMap.set(info.zipPath, newPath)
+
+      const oldName = info.zipPath.split('/').pop()
+      const newName = `slide${idx + 1}.xml`
+      nameMap.set(oldName, newName)
+    })
+
+    // Read all slide XML contents and relationships into memory first
+    const slideData = []
+    for (const info of slides) {
+      const xml = this.getSlideXml(info.index)
+      const rels = relationshipManager.getRelationships(info.zipPath)
+      slideData.push({
+        info,
+        xml,
+        rels: [...rels],
+      })
+    }
+
+    // Phase 1: Remove all old files from ZIP and clear their cache entries
+    for (const data of slideData) {
+      const oldPath = data.info.zipPath
+      const newPath = pathMap.get(oldPath)
+
+      if (oldPath !== newPath) {
+        // Remove XML file from ZIP
+        this.#zipManager.removeFile(oldPath)
+
+        // Remove .rels file from ZIP and clear RelationshipManager cache
+        const oldRelsKey = relationshipManager.getRelsPath(oldPath)
+        this.#zipManager.removeFile(oldRelsKey)
+        relationshipManager.deleteRelationships(oldPath)
+
+        // Remove content type override
+        contentTypesManager.removeOverride(oldPath)
+      }
+    }
+
+    // Phase 2: Write all new files and update cache entries
+    for (let i = 0; i < slideData.length; i++) {
+      const { info, xml, rels } = slideData[i]
+      const oldPath = info.zipPath
+      const newPath = pathMap.get(oldPath)
+
+      // Update slide XML cache key
+      this.#slideXmlCache.delete(oldPath)
+      this.#slideXmlCache.set(newPath, xml)
+
+      // Update SlideInfo path in memory
+      info.zipPath = newPath
+
+      // Write slide XML to ZIP
+      this.#zipManager.writeFile(newPath, xml)
+
+      // Add content type override
+      contentTypesManager.addOverride(newPath, SLIDE_CONTENT_TYPE)
+
+      // Set relationships for the new path in memory and flush to ZIP
+      relationshipManager.setRelationships(newPath, rels)
+      relationshipManager.flushRelationships(newPath)
+    }
+
+    // 2. Update slide-to-slide hyperlink targets and notes slide targets in all slide relationships
+    for (const info of slides) {
+      const rels = relationshipManager.getRelationships(info.zipPath)
+      let dirty = false
+      for (const rel of rels) {
+        if (rel.target && !rel.targetMode) {
+          const targetParts = rel.target.split('/')
+          const targetName = targetParts[targetParts.length - 1]
+          if (nameMap.has(targetName)) {
+            targetParts[targetParts.length - 1] = nameMap.get(targetName)
+            rel.target = targetParts.join('/')
+            dirty = true
+          }
+        }
+      }
+      if (dirty) {
+        relationshipManager.flushRelationships(info.zipPath)
+      }
+    }
+
+    // 3. Normalize notes slides: renumber them to match the slide order
+    await this.#normalizeNotesSlides(slides, relationshipManager, contentTypesManager, nameMap)
+
+    // 4. Update slide targets in presentation.xml relationships if slide filenames changed
+    const presRels = relationshipManager.getRelationships('ppt/presentation.xml')
+
+    presRels.forEach(rel => {
+      const target = rel.target
+      if (target) {
+        const targetParts = target.split('/')
+        const targetName = targetParts[targetParts.length - 1]
+        if (nameMap.has(targetName)) {
+          targetParts[targetParts.length - 1] = nameMap.get(targetName)
+          rel.target = targetParts.join('/')
+        }
+      }
+    })
+
+    // Flush relationships for ppt/presentation.xml to ZIP
+    relationshipManager.flushRelationships('ppt/presentation.xml')
+
+    // Clear any stale presentationIdMap (no longer used)
+    this.#presentationIdMap = null
+
+    // 7. Rebuild presentation.xml sldIdLst and synchronize sections
+    this.rebuildPresentationSlideOrder()
+
+    // 8. Remove orphan slide parts left over from add/remove/duplicate operations
+    this.#purgeOrphanSlideParts(slides, relationshipManager, contentTypesManager)
+  }
+
+  /**
+   * Deletes slide XML/.rels parts that are no longer referenced by the presentation.
+   * @private
+   */
+  #purgeOrphanSlideParts(slides, relationshipManager, contentTypesManager) {
+    const referenced = new Set(slides.map(s => s.zipPath))
+    const slideFiles = this.#zipManager
+      .listFiles('ppt/slides/')
+      .filter(f => /\/slide\d+\.xml$/.test(f))
+
+    for (const zipPath of slideFiles) {
+      if (referenced.has(zipPath)) continue
+
+      this.#zipManager.removeFile(zipPath)
+      const relsPath = relationshipManager.getRelsPath(zipPath)
+      this.#zipManager.removeFile(relsPath)
+      relationshipManager.deleteRelationships(zipPath)
+      contentTypesManager.removeOverride(zipPath)
+      this.#slideXmlCache.delete(zipPath)
+      logger.debug(`Purged orphan slide part: ${zipPath}`)
+    }
+  }
+
+  /**
+   * Normalizes notes slide filenames so they are sequentially numbered
+   * matching their associated slides and updates all relevant relationships.
+   * @private
+   */
+  async #normalizeNotesSlides(slides, relationshipManager, contentTypesManager, slideNameMap) {
+    const NOTES_CONTENT_TYPE =
+      'application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml'
+
+    // Collect current notes slides from slide relationships
+    const notesData = []
+    for (let i = 0; i < slides.length; i++) {
+      const info = slides[i]
+      const rels = relationshipManager.getRelationships(info.zipPath)
+      const notesRel = rels.find(r => r.type === REL_TYPES.NOTES_SLIDE)
+      if (!notesRel) continue
+
+      const oldNotesPath = relationshipManager.resolveTarget(info.zipPath, notesRel.target)
+      const newNotesFileName = `notesSlide${i + 1}.xml`
+      const newNotesPath = `ppt/notesSlides/${newNotesFileName}`
+      notesData.push({
+        slideInfo: info,
+        notesRel,
+        oldNotesPath,
+        newNotesPath,
+        newNotesFileName,
+        slideNewFileName: info.zipPath.split('/').pop(),
+      })
+    }
+
+    if (notesData.length === 0) return
+
+    // Build a map of old notes filename → new notes filename (for cross-references)
+    const notesNameMap = new Map()
+    for (const nd of notesData) {
+      const oldName = nd.oldNotesPath.split('/').pop()
+      notesNameMap.set(oldName, nd.newNotesFileName)
+    }
+
+    // Phase A: Read all notes XML and relationships into memory, then remove old files if path changes
+    for (const nd of notesData) {
+      if (nd.oldNotesPath !== nd.newNotesPath) {
+        // Load cached XML (already preloaded by preloadAll)
+        let notesXml = this.#zipManager.readCachedFile(nd.oldNotesPath)
+        if (!notesXml) {
+          // Fallback: async read from ZIP
+          notesXml = await this.#zipManager.readFile(nd.oldNotesPath)
+        }
+        nd._notesXml = notesXml
+
+        const notesRels = relationshipManager.getRelationships(nd.oldNotesPath)
+        nd._notesRels = [...notesRels]
+
+        // Remove old notes XML, .rels, and content type
+        this.#zipManager.removeFile(nd.oldNotesPath)
+        const oldRelsKey = relationshipManager.getRelsPath(nd.oldNotesPath)
+        this.#zipManager.removeFile(oldRelsKey)
+        relationshipManager.deleteRelationships(nd.oldNotesPath)
+        contentTypesManager.removeOverride(nd.oldNotesPath)
+      }
+    }
+
+    // Phase B: Write new notes files and update relationships
+    for (const nd of notesData) {
+      if (nd.oldNotesPath === nd.newNotesPath) {
+        // Path unchanged — still ensure the back-reference to the slide is correct
+        const notesRels = relationshipManager.getRelationships(nd.newNotesPath)
+        const backRef = notesRels.find(r => r.type === REL_TYPES.SLIDE || r.type.endsWith('/slide'))
+        if (backRef) {
+          const expectedTarget = `../slides/${nd.slideNewFileName}`
+          if (backRef.target !== expectedTarget) {
+            backRef.target = expectedTarget
+            relationshipManager.flushRelationships(nd.newNotesPath)
+          }
+        }
+        continue
+      }
+
+      const notesXml = nd._notesXml
+      const notesRels = nd._notesRels || []
+
+      // Update the notes rels: fix back-reference to the (possibly renamed) slide
+      for (const nr of notesRels) {
+        if (nr.type === REL_TYPES.SLIDE || nr.type.endsWith('/slide')) {
+          nr.target = `../slides/${nd.slideNewFileName}`
+        } else if (nr.target && !nr.targetMode) {
+          const parts = nr.target.split('/')
+          const fname = parts[parts.length - 1]
+          if (slideNameMap.has(fname)) {
+            parts[parts.length - 1] = slideNameMap.get(fname)
+            nr.target = parts.join('/')
+          }
+        }
+      }
+
+      // Write new notes XML to ZIP
+      if (notesXml) {
+        this.#zipManager.writeFile(nd.newNotesPath, notesXml)
+      }
+
+      // Write new notes relationships
+      relationshipManager.setRelationships(nd.newNotesPath, notesRels)
+      relationshipManager.flushRelationships(nd.newNotesPath)
+
+      // Register content type
+      contentTypesManager.addOverride(nd.newNotesPath, NOTES_CONTENT_TYPE)
+
+      // Update the slide's notes relationship target to point to the new notes path
+      const slideRels = relationshipManager.getRelationships(nd.slideInfo.zipPath)
+      const slideNotesRel = slideRels.find(r => r.type === REL_TYPES.NOTES_SLIDE)
+      if (slideNotesRel) {
+        slideNotesRel.target = `../notesSlides/${nd.newNotesFileName}`
+        relationshipManager.flushRelationships(nd.slideInfo.zipPath)
+      }
+    }
+
+    // Also update any notes-to-notes cross-references in unchanged notes
+    for (const nd of notesData) {
+      const notesRels = relationshipManager.getRelationships(nd.newNotesPath)
+      let dirty = false
+      for (const nr of notesRels) {
+        if (nr.target && !nr.targetMode) {
+          const parts = nr.target.split('/')
+          const fname = parts[parts.length - 1]
+          if (notesNameMap.has(fname)) {
+            parts[parts.length - 1] = notesNameMap.get(fname)
+            nr.target = parts.join('/')
+            dirty = true
+          }
+        }
+      }
+      if (dirty) {
+        relationshipManager.flushRelationships(nd.newNotesPath)
+      }
+    }
+  }
+
+  /**
+   * Recursively walks an in-memory parsed XML object and remaps @_r:id attribute
+   * values according to the provided ID map. This is more reliable than regex
+   * replacement on the XML string because it only targets actual relationship ID
+   * attributes, not arbitrary attribute values that might match the pattern.
+   * @private
+   * @param {Object} obj
+   * @param {Map<string,string>} idMap
+   */
+  #remapPresentationRIds(obj, idMap) {
+    if (!obj || typeof obj !== 'object') return
+    for (const key of Object.keys(obj)) {
+      if (key === '@_r:id') {
+        const currentVal = obj[key]
+        if (idMap.has(currentVal)) {
+          obj[key] = idMap.get(currentVal)
+        }
+      } else {
+        const child = obj[key]
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            this.#remapPresentationRIds(item, idMap)
+          }
+        } else if (child && typeof child === 'object') {
+          this.#remapPresentationRIds(child, idMap)
+        }
+      }
+    }
+  }
+
   markSlideObjDirty(slideIndex) {
     this.#assertSlideExists(slideIndex)
     const state = this.#slideStates.get(slideIndex)