slidemind 0.1.9 → 0.2.1

package/src/pptx/fill/xml.mjs

@@ -0,0 +1,486 @@
+// DrawingML surgery for the fill-template engine. Everything here operates on
+// slide-part XML strings from the cloned template package — the engine never
+// generates a slide from scratch, it only patches declared shapes, so every
+// helper is written to preserve the run/paragraph/cell formatting it finds.
+//
+// Two hard rules learned from PowerPoint's repair dialog (2026-07-30):
+//   - never leave text inside hMerge/vMerge continuation cells;
+//   - when a template run carries no <a:rPr>, the intended formatting usually
+//     sits in <a:endParaRPr> — fall back to it, else the theme font leaks in.
+
+export const esc = (s) =>
+  String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+export const decode = (s) =>
+  String(s)
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, "&");
+
+// Authoring-guidance highlights (yellow/green "fill me in" markers) must not
+// survive into patched runs.
+const stripHighlight = (rPr) =>
+  rPr.replace(/<a:highlight>[\s\S]*?<\/a:highlight>/g, "");
+
+// ---------------------------------------------------------------------------
+// Shape blocks
+// ---------------------------------------------------------------------------
+
+const SHAPE_TAGS = ["sp", "pic", "cxnSp", "graphicFrame"];
+
+// Top-level shape blocks of one kind. The proposal masters keep all editable
+// shapes at spTree top level (verified by inventory); grouped shapes are not
+// addressed by the pack metadata.
+export function* blocks(xml, tag) {
+  const re = new RegExp(`<p:${tag}>[\\s\\S]*?</p:${tag}>`, "g");
+  let m;
+  while ((m = re.exec(xml))) yield { block: m[0], index: m.index };
+}
+
+export function findShape(xml, id, tags = SHAPE_TAGS) {
+  for (const tag of tags) {
+    for (const hit of blocks(xml, tag)) {
+      const idm = hit.block.match(/<p:cNvPr id="(\d+)"[ />]/);
+      if (idm && idm[1] === String(id)) return { ...hit, tag };
+    }
+  }
+  return null;
+}
+
+export function maxShapeId(xml) {
+  let max = 1;
+  for (const m of xml.matchAll(/<p:cNvPr id="(\d+)"/g)) {
+    max = Math.max(max, Number(m[1]));
+  }
+  return max;
+}
+
+const replaceAt = (xml, hit, next) =>
+  xml.slice(0, hit.index) + next + xml.slice(hit.index + hit.block.length);
+
+// ---------------------------------------------------------------------------
+// Paragraphs & runs
+// ---------------------------------------------------------------------------
+
+// Formatting template for new runs, with the endParaRPr fallback: empty
+// template cells/paragraphs park their run properties there, and dropping them
+// changes fonts (the "table fonts changed" defect class).
+function paraTemplate(paraXml) {
+  const pPr = (paraXml.match(/<a:pPr[^>]*\/>|<a:pPr[\s\S]*?<\/a:pPr>/) || [""])[0];
+  let rPr = (paraXml.match(/<a:rPr[^>]*\/>|<a:rPr[\s\S]*?<\/a:rPr>/) || [""])[0];
+  if (!rPr) {
+    const end = (paraXml.match(/<a:endParaRPr[^>]*\/>|<a:endParaRPr[\s\S]*?<\/a:endParaRPr>/) || [""])[0];
+    if (end) rPr = end.replace(/endParaRPr/g, "rPr");
+  }
+  return { pPr, rPr: stripHighlight(rPr) };
+}
+
+function buildParas(lines, tmpl) {
+  return lines
+    .map((line) =>
+      line === ""
+        ? `<a:p>${tmpl.pPr}</a:p>`
+        : `<a:p>${tmpl.pPr}<a:r>${tmpl.rPr}<a:t>${esc(line)}</a:t></a:r></a:p>`,
+    )
+    .join("");
+}
+
+function firstPara(body) {
+  return (body.match(/<a:p>[\s\S]*?<\/a:p>|<a:p\/>/) || [""])[0];
+}
+
+// Replace every paragraph of a txBody, preserving the template's PER-PARAGRAPH
+// formatting: line i takes paragraph i's pPr/rPr, extra lines reuse the last
+// paragraph's (uniform bullet shapes behave exactly as before; structured
+// boxes — bold name over regular level, labeled profile lines — keep their
+// per-line styling instead of being flattened to the first paragraph's look).
+function replaceTxBodyParas(block, lines, donorTmpl = null, rPrOverride = null) {
+  const bodyM = block.match(/<p:txBody>([\s\S]*?)<\/p:txBody>/);
+  if (!bodyM) return null;
+  const body = bodyM[1];
+  const paras = [...body.matchAll(/<a:p>[\s\S]*?<\/a:p>|<a:p\/>/g)].map((m) => m[0]);
+  if (paras.length === 0) return null;
+  const tmpls = paras.map((p) => paraTemplate(p));
+  const pick = (i) => {
+    let t = tmpls[Math.min(i, tmpls.length - 1)];
+    if (!t.rPr) {
+      const styled = tmpls.find((x) => x.rPr);
+      if (styled) t = { pPr: t.pPr, rPr: styled.rPr };
+    }
+    if (!t.rPr && donorTmpl?.rPr) t = { pPr: t.pPr || donorTmpl.pPr, rPr: donorTmpl.rPr };
+    if (rPrOverride) t = { pPr: t.pPr, rPr: rPrOverride };
+    return t;
+  };
+  const rebuilt = lines.map((line, i) => buildParas([line], pick(i))).join("");
+  const parasStart = body.search(/<a:p[\s>/]/);
+  return block.replace(
+    bodyM[0],
+    `<p:txBody>${body.slice(0, parasStart)}${rebuilt}</p:txBody>`,
+  );
+}
+
+export function setShapeText(xml, id, value, log, opts = {}) {
+  const lines = Array.isArray(value) ? value : String(value).split("\n");
+  const hit = findShape(xml, id, ["sp"]);
+  if (!hit) return log.miss(`shape ${id} not found`), xml;
+  let donorTmpl = null;
+  if (opts.donorId) {
+    const donor = findShape(xml, opts.donorId, ["sp"]);
+    if (donor) donorTmpl = paraTemplate(firstPara(donor.block));
+  }
+  const patched = replaceTxBodyParas(hit.block, lines, donorTmpl, opts.rPrOverride ?? null);
+  if (!patched) return log.miss(`shape ${id} has no txBody`), xml;
+  log.ok(`shape ${id}`);
+  return replaceAt(xml, hit, patched);
+}
+
+// Style probes for state-swaps (e.g. the approach chevron highlight): the
+// template's own shapes are the source of truth for both states.
+export function shapeFillXml(xml, id) {
+  const hit = findShape(xml, id, ["sp"]);
+  const spPr = hit?.block.match(/<p:spPr>[\s\S]*?<\/p:spPr>/)?.[0] ?? "";
+  return (spPr.match(/<a:solidFill>[\s\S]*?<\/a:solidFill>/) || [null])[0];
+}
+
+export function shapeRunRPr(xml, id) {
+  const hit = findShape(xml, id, ["sp"]);
+  if (!hit) return null;
+  return paraTemplate(firstPara(hit.block)).rPr || null;
+}
+
+export function setShapeFillXml(xml, id, fillXml, log) {
+  const hit = findShape(xml, id, ["sp"]);
+  if (!hit || !fillXml) return xml;
+  const spPr = hit.block.match(/<p:spPr>[\s\S]*?<\/p:spPr>/);
+  if (!spPr) return xml;
+  let next = spPr[0];
+  next = /<a:solidFill>[\s\S]*?<\/a:solidFill>/.test(next)
+    ? next.replace(/<a:solidFill>[\s\S]*?<\/a:solidFill>/, fillXml)
+    : next.replace(/(<\/a:prstGeom>|<\/a:custGeom>)/, `$1${fillXml}`);
+  log.ok(`shape ${id} restyled`);
+  return replaceAt(xml, hit, hit.block.replace(spPr[0], next));
+}
+
+// Rewrite only paragraph <index> of a shape (slide 7's baked-header layout).
+export function setParagraphText(xml, id, index, text, log) {
+  const hit = findShape(xml, id, ["sp"]);
+  if (!hit) return log.miss(`shape ${id} not found`), xml;
+  const paras = [...hit.block.matchAll(/<a:p>[\s\S]*?<\/a:p>/g)];
+  if (index >= paras.length) return log.miss(`shape ${id} ¶${index} out of range`), xml;
+  const tmpl = paraTemplate(paras[index][0]);
+  const rebuilt = `<a:p>${tmpl.pPr}<a:r>${tmpl.rPr}<a:t>${esc(text)}</a:t></a:r></a:p>`;
+  const block =
+    hit.block.slice(0, paras[index].index) +
+    rebuilt +
+    hit.block.slice(paras[index].index + paras[index][0].length);
+  log.ok(`shape ${id} ¶${index}`);
+  return replaceAt(xml, hit, block);
+}
+
+export function setShapeFill(xml, id, hex, log) {
+  const hit = findShape(xml, id, ["sp"]);
+  if (!hit) return log.miss(`shape ${id} not found`), xml;
+  const fill = `<a:solidFill><a:srgbClr val="${String(hex).replace(/^#/, "")}"/></a:solidFill>`;
+  let block = hit.block;
+  const spPr = block.match(/<p:spPr>[\s\S]*?<\/p:spPr>/);
+  if (!spPr) return log.miss(`shape ${id} has no spPr`), xml;
+  let next = spPr[0];
+  if (/<a:solidFill>[\s\S]*?<\/a:solidFill>/.test(next)) {
+    next = next.replace(/<a:solidFill>[\s\S]*?<\/a:solidFill>/, fill);
+  } else {
+    // Insert after geometry so the fill lands in spPr's property order.
+    next = next.replace(/(<\/a:prstGeom>|<\/a:custGeom>)/, `$1${fill}`);
+  }
+  log.ok(`shape ${id} fill #${hex}`);
+  return replaceAt(xml, hit, block.replace(spPr[0], next));
+}
+
+export function deleteShapes(xml, ids, log) {
+  let out = xml;
+  for (const id of ids) {
+    const hit = findShape(out, id);
+    if (!hit) { log.miss(`delete: shape ${id} not found`); continue; }
+    out = replaceAt(out, hit, "");
+    log.ok(`deleted shape ${id}`);
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Geometry (EMU) — repeats reposition member shapes
+// ---------------------------------------------------------------------------
+
+export function getGeom(xml, id) {
+  const hit = findShape(xml, id);
+  if (!hit) return null;
+  const m = hit.block.match(/<a:off x="(-?\d+)" y="(-?\d+)"\/><a:ext cx="(\d+)" cy="(\d+)"\/>/);
+  if (!m) return null;
+  return { x: Number(m[1]), y: Number(m[2]), cx: Number(m[3]), cy: Number(m[4]) };
+}
+
+export function setGeom(xml, id, geom, log) {
+  const hit = findShape(xml, id);
+  if (!hit) return log.miss(`geom: shape ${id} not found`), xml;
+  const block = hit.block.replace(
+    /<a:off x="-?\d+" y="-?\d+"\/><a:ext cx="\d+" cy="\d+"\/>/,
+    `<a:off x="${Math.round(geom.x)}" y="${Math.round(geom.y)}"/><a:ext cx="${Math.round(geom.cx)}" cy="${Math.round(geom.cy)}"/>`,
+  );
+  return replaceAt(xml, hit, block);
+}
+
+// Clone a top-level shape with a fresh id, appended just after the original so
+// z-order stays local. Returns { xml, newId }.
+export function cloneShape(xml, id, log) {
+  const hit = findShape(xml, id);
+  if (!hit) return log.miss(`clone: shape ${id} not found`), { xml, newId: null };
+  const newId = maxShapeId(xml) + 1;
+  const clone = hit.block.replace(
+    /(<p:cNvPr id=")\d+(")/,
+    `$1${newId}$2`,
+  );
+  log.ok(`cloned shape ${id} → ${newId}`);
+  return {
+    xml: xml.slice(0, hit.index + hit.block.length) + clone + xml.slice(hit.index + hit.block.length),
+    newId,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Native tables (a:tbl in a p:graphicFrame)
+// ---------------------------------------------------------------------------
+
+export function cellText(tc) {
+  return [...tc.matchAll(/<a:t>([^<]*)<\/a:t>/g)].map((m) => decode(m[1])).join("");
+}
+
+function setCell(tc, text, donorTmpl = null) {
+  const bodyM = tc.match(/<a:txBody>([\s\S]*?)<\/a:txBody>/);
+  if (!bodyM) return tc;
+  let tmpl = paraTemplate(firstPara(bodyM[1]));
+  if (!tmpl.rPr && donorTmpl?.rPr) tmpl = { pPr: tmpl.pPr || donorTmpl.pPr, rPr: donorTmpl.rPr };
+  const parasStart = bodyM[1].search(/<a:p[\s>/]/);
+  if (parasStart < 0) return tc;
+  return tc.replace(
+    bodyM[0],
+    `<a:txBody>${bodyM[1].slice(0, parasStart)}${buildParas([String(text)], tmpl)}</a:txBody>`,
+  );
+}
+
+const isContinuation = (tc) => /\bhMerge="1"|\bvMerge="1"/.test(tc.slice(0, tc.indexOf(">")));
+
+function parseTable(block) {
+  const grid = [...block.matchAll(/<a:gridCol w="(\d+)"[^>]*\/>|<a:gridCol w="(\d+)"[^>]*>[\s\S]*?<\/a:gridCol>/g)];
+  const rows = [...block.matchAll(/<a:tr [\s\S]*?<\/a:tr>/g)].map((m) => ({
+    xml: m[0],
+    cells: [...m[0].matchAll(/<a:tc[^>]*\/>|<a:tc[^>]*>[\s\S]*?<\/a:tc>/g)].map((c) => c[0]),
+  }));
+  return { grid, rows };
+}
+
+// Rebuild ONE row's cells by POSITION. Never replace by content needle:
+// after reshaping, sibling cells can be byte-identical, and String.replace
+// then patches the wrong cell (the silently-wrong-price defect class).
+function rebuildRow(rowXml, transform) {
+  const rowOpen = rowXml.slice(0, rowXml.indexOf(">") + 1);
+  const cells = [...rowXml.matchAll(/<a:tc[^>]*\/>|<a:tc[^>]*>[\s\S]*?<\/a:tc>/g)].map((m) => m[0]);
+  return rowOpen + cells.map((tc, i) => transform(tc, i)).join("") + "</a:tr>";
+}
+
+// Fill a native table from a full positional array-of-rows, with structural
+// edits: the FIRST author row maps to the first table row, the LAST to the
+// last, middle rows map in order (surplus template middle rows are deleted,
+// extra author middle rows clone the last template middle row). Columns get
+// the same first/last anchoring: middle columns are cloned/removed to match
+// the author's column count, redistributing the freed/needed width across the
+// middle so total table width is stable. Continuation cells of merges are
+// always emptied. The table is reassembled from arrays end-to-end — no
+// content-based replacement anywhere.
+export function fillTable(xml, frameId, rowsIn, log) {
+  const hit = findShape(xml, frameId, ["graphicFrame"]);
+  if (!hit) return log.miss(`table ${frameId} not found`), xml;
+  let block = hit.block;
+  let { grid, rows } = parseTable(block);
+  if (rows.length < 2 || rowsIn.length < 2) {
+    return log.miss(`table ${frameId}: need header+body rows`), xml;
+  }
+
+  let rowXmls = rows.map((r) => r.xml);
+  const colsWanted = Math.max(...rowsIn.map((r) => r.length));
+  const colsHave = grid.length;
+
+  // --- column structure -------------------------------------------------------
+  if (colsWanted !== colsHave) {
+    if (colsWanted < 3 || colsHave < 3) {
+      return log.miss(`table ${frameId}: column reshape needs ≥3 columns`), xml;
+    }
+    const widths = grid.map((g) => Number(g[1] ?? g[2]));
+    const total = widths.reduce((a, b) => a + b, 0);
+    const midCount = colsWanted - 2;
+    const midW = Math.floor((total - widths[0] - widths[widths.length - 1]) / midCount);
+    const newWidths = [widths[0], ...Array(midCount).fill(midW), widths[widths.length - 1]];
+    newWidths[newWidths.length - 2] += total - newWidths.reduce((a, b) => a + b, 0);
+    block = block.replace(
+      /<a:tblGrid>[\s\S]*?<\/a:tblGrid>/,
+      `<a:tblGrid>${newWidths.map((w) => `<a:gridCol w="${w}"/>`).join("")}</a:tblGrid>`,
+    );
+
+    rowXmls = rowXmls.map((rowXml) => {
+      const cells = [...rowXml.matchAll(/<a:tc[^>]*\/>|<a:tc[^>]*>[\s\S]*?<\/a:tc>/g)].map((m) => m[0]);
+      const rowOpen = rowXml.slice(0, rowXml.indexOf(">") + 1);
+      // A merged row still carries colsHave physical tcs (continuations are
+      // real cells) — detect merges by attributes, never by cell count.
+      const merged = cells.some((c) => /gridSpan="/.test(c) || isContinuation(c));
+      if (!merged) {
+        const mids = Array(midCount).fill(cells[1]);
+        return rowOpen + [cells[0], ...mids, cells[cells.length - 1]].join("") + "</a:tr>";
+      }
+      // Merged row: re-anchor the span to the new middle count and rebuild the
+      // matching number of continuation cells. gridSpan="1" is never written —
+      // PowerPoint's writer omits the attribute at span 1.
+      const spanAttr = midCount > 1 ? ` gridSpan="${midCount}"` : "";
+      const anchorIdx = cells.findIndex((c) => /gridSpan="/.test(c));
+      if (anchorIdx < 0) return rowXml;
+      const contTemplate = cells.find(isContinuation) ?? "";
+      const keep = cells
+        .filter((c) => !isContinuation(c))
+        .map((c) => c.replace(/ gridSpan="\d+"/, spanAttr));
+      keep.splice(anchorIdx + 1, 0, ...Array(Math.max(0, midCount - 1)).fill(contTemplate));
+      return rowOpen + keep.join("") + "</a:tr>";
+    });
+    log.ok(`table ${frameId}: columns ${colsHave} → ${colsWanted}`);
+  }
+
+  // --- row structure -----------------------------------------------------------
+  const wantMid = rowsIn.length - 2;
+  const haveMid = rowXmls.length - 2;
+  if (wantMid < haveMid) {
+    rowXmls.splice(1 + wantMid, haveMid - wantMid);
+    log.ok(`table ${frameId}: trimmed ${haveMid - wantMid} template row(s)`);
+  } else if (wantMid > haveMid) {
+    const template = rowXmls[rowXmls.length - 2];
+    rowXmls.splice(rowXmls.length - 1, 0, ...Array(wantMid - haveMid).fill(template));
+    log.ok(`table ${frameId}: cloned ${wantMid - haveMid} row(s)`);
+  }
+
+  // --- content -------------------------------------------------------------------
+  // Donor formatting for cells whose template carries neither rPr nor
+  // endParaRPr: the same column's header-adjacent body cell.
+  const donorCells = [...(rowXmls[1] ?? "").matchAll(/<a:tc[^>]*\/>|<a:tc[^>]*>[\s\S]*?<\/a:tc>/g)].map((m) => m[0]);
+  rowXmls = rowXmls.map((rowXml, r) => {
+    const values = rowsIn[r] ?? [];
+    return rebuildRow(rowXml, (tc, i) => {
+      if (isContinuation(tc)) return setCell(tc, "");
+      if (values[i] === undefined) return tc;
+      const donorTmpl = donorCells[i] ? paraTemplate(firstPara(donorCells[i])) : null;
+      return setCell(tc, values[i], donorTmpl);
+    });
+  });
+
+  const bodyStart = block.indexOf("<a:tr ");
+  const bodyEnd = block.lastIndexOf("</a:tr>") + "</a:tr>".length;
+  block = block.slice(0, bodyStart) + rowXmls.join("") + block.slice(bodyEnd);
+
+  log.ok(`table ${frameId}: ${rowsIn.length} rows written`);
+  return replaceAt(xml, hit, block);
+}
+
+// Guard used by the integrity pass: no text may survive inside continuation
+// cells anywhere in the package.
+export function mergedCellViolations(xml) {
+  let n = 0;
+  for (const m of xml.matchAll(/<a:tc[^>]*(?:hMerge="1"|vMerge="1")[^>]*>([\s\S]*?)<\/a:tc>/g)) {
+    if (cellText(m[1]).trim()) n++;
+  }
+  return n;
+}
+
+// ---------------------------------------------------------------------------
+// Pictures
+// ---------------------------------------------------------------------------
+
+// Minimal raster header probe (png/jpeg) for cover-crop math.
+export function imageSize(buf) {
+  if (buf[0] === 0x89 && buf[1] === 0x50) {
+    return { w: readU32(buf, 16), h: readU32(buf, 20) };
+  }
+  if (buf[0] === 0xff && buf[1] === 0xd8) {
+    let i = 2;
+    while (i < buf.length - 9) {
+      if (buf[i] !== 0xff) { i++; continue; }
+      const marker = buf[i + 1];
+      const len = (buf[i + 2] << 8) | buf[i + 3];
+      if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+        return { h: (buf[i + 5] << 8) | buf[i + 6], w: (buf[i + 7] << 8) | buf[i + 8] };
+      }
+      i += 2 + len;
+    }
+  }
+  return null;
+}
+const readU32 = (b, o) => (b[o] << 24 | b[o + 1] << 16 | b[o + 2] << 8 | b[o + 3]) >>> 0;
+
+// Center-crop srcRect (per-mille) so the image COVERS the target box.
+function coverSrcRect(imgW, imgH, boxW, boxH) {
+  const scale = Math.max(boxW / imgW, boxH / imgH);
+  const cropW = boxW / scale / imgW;
+  const cropH = boxH / scale / imgH;
+  const l = Math.round(((1 - cropW) / 2) * 100000);
+  const t = Math.round(((1 - cropH) / 2) * 100000);
+  return `<a:srcRect l="${l}" t="${t}" r="${l}" b="${t}"/>`;
+}
+
+// Build a <p:pic> for a target box. fit "cover" center-crops via srcRect;
+// fit "contain" shrinks the drawn extents to the image aspect, centered.
+function picXml(newId, relId, imgDims, box, fit) {
+  let { x, y, cx, cy } = box;
+  let src = "";
+  if (imgDims) {
+    if (fit === "contain") {
+      const scale = Math.min(cx / imgDims.w, cy / imgDims.h);
+      const w = Math.round(imgDims.w * scale);
+      const h = Math.round(imgDims.h * scale);
+      x = Math.round(x + (cx - w) / 2);
+      y = Math.round(y + (cy - h) / 2);
+      cx = w;
+      cy = h;
+    } else {
+      src = coverSrcRect(imgDims.w, imgDims.h, cx, cy);
+    }
+  }
+  return (
+    `<p:pic><p:nvPicPr><p:cNvPr id="${newId}" name="Picture ${newId}"/>` +
+    `<p:cNvPicPr><a:picLocks noChangeAspect="1"/></p:cNvPicPr><p:nvPr/></p:nvPicPr>` +
+    `<p:blipFill><a:blip r:embed="${relId}"/>${src}<a:stretch><a:fillRect/></a:stretch></p:blipFill>` +
+    `<p:spPr><a:xfrm><a:off x="${x}" y="${y}"/><a:ext cx="${cx}" cy="${cy}"/></a:xfrm>` +
+    `<a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr></p:pic>`
+  );
+}
+
+// Insert a contain-fit picture at a free box (the anchor shape is gone).
+export function insertPictureAtGeom(xml, geom, relId, imgDims, log) {
+  const newId = maxShapeId(xml) + 1;
+  const pic = picXml(newId, relId, imgDims, geom, "contain");
+  const end = xml.lastIndexOf("</p:spTree>");
+  if (end < 0) return log.miss("no spTree for picture"), xml;
+  log.ok("picture placed (contain-fit)");
+  return xml.slice(0, end) + pic + xml.slice(end);
+}
+
+// Insert a new <p:pic> covering an anchor shape's box, z-ordered directly
+// below ("behind") or above it. relId/media part are the caller's business.
+export function insertPicture(xml, anchorId, relId, imgDims, opts, log) {
+  const hit = findShape(xml, anchorId);
+  if (!hit) return log.miss(`image anchor ${anchorId} not found`), xml;
+  const geom = getGeom(xml, anchorId);
+  if (!geom) return log.miss(`image anchor ${anchorId} has no geometry`), xml;
+  const newId = maxShapeId(xml) + 1;
+  const pic = picXml(newId, relId, imgDims, geom, opts.fit ?? "cover");
+  const out =
+    opts.z === "above"
+      ? xml.slice(0, hit.index + hit.block.length) + pic + xml.slice(hit.index + hit.block.length)
+      : xml.slice(0, hit.index) + pic + xml.slice(hit.index);
+  log.ok(`picture inserted ${opts.z === "above" ? "over" : "behind"} shape ${anchorId}`);
+  return out;
+}

package/src/pptx/ooxml.mjs

@@ -20,12 +20,19 @@ export function slideOrderPaths(files) {
   if (!presXml) return [];
 
   // Isolate the sldIdLst so a stray r:id elsewhere in the part can't leak in.
-  const listMatch = /<p:sldIdLst[\s\S]*?<\/p:sldIdLst>/.exec(presXml);
+  // PREFIX-TOLERANT: the canonical serializers write `p:`/`r:`, but engine
+  // slide slices arrive with generic `ns0:`/`ns1:` prefixes (Python
+  // ElementTree serialization) — prefixes are arbitrary in XML, only the bound
+  // namespaces matter, and a `p:`-only match reported such packages as having
+  // zero slides.
+  const listMatch = /<(?:[\w.-]+:)?sldIdLst[\s\S]*?<\/(?:[\w.-]+:)?sldIdLst>/.exec(presXml);
   if (!listMatch) return [];
 
-  // r:id in document order (the on-screen slide sequence).
+  // r:id in document order (the on-screen slide sequence). The relationship-id
+  // attribute is the one namespaced `…:id` attr on sldId (its OTHER attribute,
+  // the slide id, is unprefixed `id=`).
   const rIds = [];
-  const idRe = /<p:sldId\b[^>]*\br:id\s*=\s*"([^"]+)"/g;
+  const idRe = /<(?:[\w.-]+:)?sldId\b[^>]*?\s[\w.-]+:id\s*=\s*"([^"]+)"/g;
   let m;
   while ((m = idRe.exec(listMatch[0])) !== null) rIds.push(m[1]);