slidemind 0.1.7 → 0.1.9

package/src/builders/visual-families.mjs

@@ -0,0 +1,32 @@
+import { splitPlanMarkdownIntoSegments } from "./storyboard-markdown.mjs";
+
+/**
+ * Split a per-slide concept batch into the dependency waves expected by the
+ * add-in: independent slides and family anchors first, family variants second.
+ */
+export function conceptGenerationWaves(planMarkdown, slideCount) {
+  const groups = new Map();
+  for (const segment of splitPlanMarkdownIntoSegments(planMarkdown)) {
+    if (segment.type !== "storyboard" || !segment.data) continue;
+    const family = segment.data.visualFamily?.trim();
+    const slide = segment.data.slide;
+    if (!family || !Number.isFinite(slide)) continue;
+    groups.set(family, [...(groups.get(family) ?? []), slide]);
+  }
+
+  const variants = new Set();
+  for (const unsorted of groups.values()) {
+    const members = [...new Set(unsorted)].sort((a, b) => a - b);
+    if (members.length < 2) continue;
+    for (const slide of members.slice(1)) variants.add(slide);
+  }
+
+  const remaining = Array.from(
+    { length: Math.max(0, slideCount - 1) },
+    (_, index) => index + 2,
+  );
+  return {
+    firstWave: remaining.filter((slide) => !variants.has(slide)),
+    variants: remaining.filter((slide) => variants.has(slide)),
+  };
+}

package/src/pptx/app-props.mjs

@@ -0,0 +1,222 @@
+// Normalize PowerPoint package metadata after server-side assembly.
+//
+// The render backend can assemble authored JSX slides plus reused native .pptx
+// slides correctly while leaving docProps/app.xml counted from the JSX-only
+// source deck. PowerPoint treats stale <Slides>, HeadingPairs, or TitlesOfParts
+// metadata as repairable corruption on open. This post-process keeps those
+// extended properties aligned with the actual slide order in ppt/presentation.xml.
+//
+// Reused native slides can also bring duplicate copies of a source deck's slide
+// master tree. Those copies legitimately need distinct relationship targets, but
+// PowerPoint allocates <p:sldMasterId id> and <p:sldLayoutId id> from a single
+// shared id space and treats any collision across that whole space as repairable
+// corruption on open. A splicer that assigns new master ids from a watermark that
+// only scanned presentation.xml can hand a spliced master the same numeric id as
+// an existing brand layout. Treat the sldMasterId values as fixed anchors and
+// renumber only the colliding sldLayoutId values, keeping every r:id pointer
+// untouched and never rewriting presentation.xml.
+
+import { unzip, zip, readText } from "./zip.mjs";
+import { slideOrderPaths, decodeXmlEntities } from "./ooxml.mjs";
+import { slideText } from "./read-local.mjs";
+import { stripHiddenOleGraphicFrames } from "./hidden-ole.mjs";
+import { stripRiskyImageExtensions } from "./image-extensions.mjs";
+
+const APP_PROPS = "docProps/app.xml";
+
+export function normalizePptxAppProperties(buffer) {
+  let files;
+  try {
+    files = unzip(buffer);
+  } catch {
+    return { bytes: buffer, changed: false, slideCount: null };
+  }
+
+  if (!files["ppt/presentation.xml"]) {
+    return { bytes: buffer, changed: false, slideCount: null };
+  }
+
+  const order = slideOrderPaths(files);
+  const slideCount = order.length;
+  let entries = files;
+  let changed = false;
+
+  const before = readText(files, APP_PROPS);
+  if (before && slideCount > 0) {
+    let after = replaceElementText(before, "Slides", String(slideCount));
+    after = replaceSlideTitleHeadingCount(after, slideCount);
+    after = replaceTitlesOfParts(after, slideTitles(files, order));
+    if (after !== before) {
+      entries = { ...entries, [APP_PROPS]: new TextEncoder().encode(after) };
+      changed = true;
+    }
+  }
+
+  const idResult = normalizeMasterAndLayoutIds(entries);
+  if (idResult.changed) {
+    entries = idResult.entries;
+    changed = true;
+  }
+
+  if (stripHiddenOleGraphicFrames(entries)) {
+    changed = true;
+  }
+  if (stripRiskyImageExtensions(entries)) {
+    changed = true;
+  }
+
+  return {
+    bytes: changed ? zip(entries) : buffer,
+    changed,
+    slideCount,
+  };
+}
+
+export function normalizePptxAppPropertiesBase64(base64) {
+  const normalized = normalizePptxAppProperties(Buffer.from(base64, "base64"));
+  if (!normalized.changed) {
+    return { ...normalized, base64 };
+  }
+  return {
+    ...normalized,
+    base64: Buffer.from(normalized.bytes).toString("base64"),
+  };
+}
+
+function slideTitles(files, order) {
+  return order.map((slidePath, i) => {
+    const xml = readText(files, slidePath) ?? "";
+    const { title, subtitle } = slideText(xml);
+    return title || subtitle || `Slide ${i + 1}`;
+  });
+}
+
+const LAYOUT_ID_FLOOR = 2147483648;
+
+function normalizeMasterAndLayoutIds(files) {
+  const masterParts = Object.keys(files)
+    .filter((part) => /^ppt\/slideMasters\/slideMaster\d+\.xml$/.test(part))
+    .sort(numericPartSort);
+  if (masterParts.length === 0) return { entries: files, changed: false };
+
+  // sldMasterId values live in presentation.xml and are the fixed anchors of the
+  // shared id space — never renumbered here (that would mean rewriting
+  // presentation.xml, and a master-vs-master collision is the server's to fix).
+  const presentationXml = readText(files, "ppt/presentation.xml") ?? "";
+  const masterIds = [];
+  for (const tag of presentationXml.matchAll(/<p:sldMasterId\b[^>]*>/g)) {
+    const id = attr(tag[0], "id");
+    if (id !== null) masterIds.push(id);
+  }
+
+  const layoutIds = [];
+  for (const part of masterParts) {
+    const xml = readText(files, part) ?? "";
+    for (const tag of xml.matchAll(/<p:sldLayoutId\b[^>]*>/g)) {
+      const id = attr(tag[0], "id");
+      if (id !== null) layoutIds.push(id);
+    }
+  }
+
+  // Inert unless the master and layout ids collide somewhere across the union —
+  // keeps well-formed (and server-fixed) output byte-stable.
+  const union = [...masterIds, ...layoutIds];
+  if (new Set(union).size === union.length) {
+    return { entries: files, changed: false };
+  }
+
+  const numericIds = union.map((id) => Number(id)).filter(Number.isFinite);
+  let nextId = numericIds.length ? Math.max(...numericIds) + 1 : LAYOUT_ID_FLOOR;
+
+  // Seed with the master anchors so a layout id equal to a master id is treated
+  // as a collision and moved off it. Then walk masters/layouts in document order,
+  // renumbering only ids already claimed.
+  const seen = new Set(masterIds);
+  let entries = files;
+  let changed = false;
+
+  for (const part of masterParts) {
+    const before = readText(files, part) ?? "";
+    const after = before.replace(/<p:sldLayoutId\b[^>]*>/g, (tag) => {
+      const id = attr(tag, "id");
+      if (id === null || !seen.has(id)) {
+        if (id !== null) seen.add(id);
+        return tag;
+      }
+      while (seen.has(String(nextId))) nextId += 1;
+      const replacement = String(nextId);
+      nextId += 1;
+      seen.add(replacement);
+      return replaceAttr(tag, "id", replacement);
+    });
+    if (after !== before) {
+      entries = { ...entries, [part]: new TextEncoder().encode(after) };
+      changed = true;
+    }
+  }
+
+  return { entries, changed };
+}
+
+function replaceElementText(xml, tagName, value) {
+  return xml.replace(
+    new RegExp(`(<${tagName}>)[\\s\\S]*?(</${tagName}>)`),
+    `$1${value}$2`,
+  );
+}
+
+function attr(tag, name) {
+  const m = new RegExp(`(^|\\s)${name}="([^"]*)"`).exec(tag);
+  return m ? m[2] : null;
+}
+
+function replaceAttr(tag, name, value) {
+  return tag.replace(
+    new RegExp(`(^|\\s)${name}="[^"]*"`),
+    `$1${name}="${value}"`,
+  );
+}
+
+function numericPartSort(a, b) {
+  const na = Number(a.match(/(\d+)\.xml$/)?.[1] ?? 0);
+  const nb = Number(b.match(/(\d+)\.xml$/)?.[1] ?? 0);
+  return na - nb || a.localeCompare(b);
+}
+
+function replaceSlideTitleHeadingCount(xml, slideCount) {
+  return xml.replace(
+    /(<vt:variant>\s*<vt:lpstr>Slide Titles<\/vt:lpstr>\s*<\/vt:variant>\s*<vt:variant>\s*<vt:i4>)-?\d+(<\/vt:i4>\s*<\/vt:variant>)/,
+    `$1${slideCount}$2`,
+  );
+}
+
+function replaceTitlesOfParts(xml, titles) {
+  return xml.replace(
+    /<TitlesOfParts>\s*<vt:vector\b[^>]*>[\s\S]*?<\/vt:vector>\s*<\/TitlesOfParts>/,
+    (match) => {
+      const themeName = firstLpstr(match) || "Theme";
+      const values = [themeName, ...titles]
+        .map((title) => `<vt:lpstr>${escapeXml(title)}</vt:lpstr>`)
+        .join("");
+      return (
+        `<TitlesOfParts><vt:vector size="${titles.length + 1}" baseType="lpstr">` +
+        values +
+        `</vt:vector></TitlesOfParts>`
+      );
+    },
+  );
+}
+
+function firstLpstr(xml) {
+  const m = /<vt:lpstr>([\s\S]*?)<\/vt:lpstr>/.exec(xml);
+  return m ? decodeXmlEntities(m[1]) : null;
+}
+
+function escapeXml(value) {
+  return String(value)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}

package/src/pptx/hidden-ole.mjs

@@ -0,0 +1,125 @@
+import { readText } from "./zip.mjs";
+import { relsFor, relsPathFor, resolvePartPath } from "./ooxml.mjs";
+
+const CONTENT_TYPES = "[Content_Types].xml";
+
+export function stripHiddenOleGraphicFrames(files) {
+  let changed = false;
+  const removedTargets = new Set();
+  const candidates = Object.keys(files).filter((part) =>
+    /^ppt\/(?:slides|slideMasters|slideLayouts)\/[^/]+\.xml$/.test(part),
+  );
+
+  for (const part of candidates) {
+    const before = readText(files, part);
+    if (!before) continue;
+
+    const removedIds = new Set();
+    const after = before.replace(
+      /<p:graphicFrame\b[\s\S]*?<\/p:graphicFrame>/g,
+      (frame) => {
+        if (!/<p:oleObj\b/.test(frame) || !/\bhidden="1"/.test(frame)) return frame;
+        for (const id of relationshipIdsIn(frame)) removedIds.add(id);
+        return "";
+      },
+    );
+    if (after === before) continue;
+
+    files[part] = new TextEncoder().encode(after);
+    changed = true;
+
+    const relsPath = relsPathFor(part);
+    const relsXml = readText(files, relsPath);
+    if (!relsXml) continue;
+
+    const partDir = part.includes("/") ? part.slice(0, part.lastIndexOf("/")) : "";
+    const relsById = new Map(relsFor(files, part).map((rel) => [rel.id, rel]));
+    const remainingIds = relationshipIdsIn(after);
+    let nextRels = relsXml;
+    for (const id of removedIds) {
+      if (remainingIds.has(id)) continue;
+      nextRels = removeRelationshipById(nextRels, id);
+      const rel = relsById.get(id);
+      if (rel && rel.targetMode !== "External") {
+        removedTargets.add(resolvePartPath(partDir, rel.target));
+      }
+    }
+    if (nextRels !== relsXml) {
+      files[relsPath] = new TextEncoder().encode(nextRels);
+    }
+  }
+
+  const deleted = deleteUnreferencedTargets(files, removedTargets);
+  if (deleted.size > 0) {
+    removeContentTypeOverrides(files, deleted);
+    changed = true;
+  }
+
+  return changed;
+}
+
+function deleteUnreferencedTargets(files, removedTargets) {
+  const remainingRefs = referencedInternalTargets(files);
+  const deleted = new Set();
+  for (const part of removedTargets) {
+    if (!part || remainingRefs.has(part) || files[part] === undefined) continue;
+    delete files[part];
+    const sidecar = relsPathFor(part);
+    if (files[sidecar] !== undefined) delete files[sidecar];
+    deleted.add(part);
+  }
+  return deleted;
+}
+
+function referencedInternalTargets(files) {
+  const refs = new Set();
+  for (const relsPath of Object.keys(files)) {
+    if (!relsPath.endsWith(".rels")) continue;
+    const dir = relsPath.replace(/\/?_rels\/[^/]+$/, "");
+    const owner =
+      dir === ""
+        ? relsPath.replace(/^_rels\/(.*)\.rels$/, "$1")
+        : `${dir}/${relsPath.replace(/^.*_rels\/(.*)\.rels$/, "$1")}`;
+    for (const rel of relsFor(files, owner)) {
+      if (rel.targetMode === "External") continue;
+      refs.add(resolvePartPath(dir, rel.target));
+    }
+  }
+  return refs;
+}
+
+function removeContentTypeOverrides(files, deletedParts) {
+  const before = readText(files, CONTENT_TYPES);
+  if (!before) return;
+  let after = before;
+  for (const part of deletedParts) {
+    after = after.replace(
+      new RegExp(
+        `<Override\\b(?=[^>]*\\bPartName="/${escapeRe(part)}")[^>]*?/>`,
+        "g",
+      ),
+      "",
+    );
+  }
+  if (after !== before) files[CONTENT_TYPES] = new TextEncoder().encode(after);
+}
+
+function relationshipIdsIn(xml) {
+  const ids = new Set();
+  for (const m of String(xml).matchAll(/\br:(?:id|embed|link)\s*=\s*"([^"]+)"/g)) {
+    ids.add(m[1]);
+  }
+  return ids;
+}
+
+function removeRelationshipById(xml, id) {
+  return xml.replace(
+    new RegExp(
+      `<Relationship\\b(?=[^>]*\\bId="${escapeRe(id)}")[^>]*?(?:/>|>[\\s\\S]*?</Relationship>)`,
+      "g",
+    ),
+    "",
+  );
+}
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/src/pptx/image-extensions.mjs

@@ -0,0 +1,190 @@
+import { readText } from "./zip.mjs";
+import { relsFor, relsPathFor, resolvePartPath } from "./ooxml.mjs";
+
+const CONTENT_TYPES = "[Content_Types].xml";
+
+export function stripRiskyImageExtensions(files) {
+  let changed = false;
+  const removedTargets = new Set();
+  const candidates = Object.keys(files).filter((part) =>
+    /^ppt\/(?:slides|slideMasters|slideLayouts)\/[^/]+\.xml$/.test(part),
+  );
+
+  for (const part of candidates) {
+    const before = readText(files, part);
+    if (!before) continue;
+
+    const removedIds = new Set();
+    const relsById = new Map(relsFor(files, part).map((rel) => [rel.id, rel]));
+    const partDir = part.includes("/") ? part.slice(0, part.lastIndexOf("/")) : "";
+    let after = before.replace(
+      /<a:ext\b[\s\S]*?<\/a:ext>/g,
+      (ext) => {
+        if (!/<(?:asvg:svgBlip|a14:imgLayer)\b/.test(ext)) return ext;
+        for (const id of relationshipIdsIn(ext)) removedIds.add(id);
+        return "";
+      },
+    );
+    after = after.replace(/<a:extLst\b[^>]*>\s*<\/a:extLst>/g, "");
+    after = after.replace(
+      /<p:pic\b[\s\S]*?<\/p:pic>/g,
+      (pic) => {
+        if (!/<a:blip\b(?![^>]*\br:(?:embed|link)=)[^>]*>\s*<\/a:blip>/.test(pic)) {
+          return pic;
+        }
+        for (const id of relationshipIdsIn(pic)) removedIds.add(id);
+        return "";
+      },
+    );
+    after = after.replace(
+      /<p:pic\b[\s\S]*?<\/p:pic>/g,
+      (pic) => {
+        for (const id of relationshipIdsIn(pic)) {
+          const rel = relsById.get(id);
+          if (
+            rel &&
+            rel.targetMode !== "External" &&
+            /\.svg(?:$|[?#])/i.test(rel.target ?? "")
+          ) {
+            removedIds.add(id);
+            return "";
+          }
+        }
+        return pic;
+      },
+    );
+    const relsPath = relsPathFor(part);
+    const relsXml = readText(files, relsPath);
+    const remainingIds = relationshipIdsIn(after);
+    if (relsXml) {
+      for (const rel of relsById.values()) {
+        if (
+          rel.targetMode !== "External" &&
+          !remainingIds.has(rel.id) &&
+          /\.(?:svg|wdp)(?:$|[?#])/i.test(rel.target ?? "")
+        ) {
+          removedIds.add(rel.id);
+        }
+      }
+    }
+
+    if (after === before && removedIds.size === 0) continue;
+
+    if (after !== before) {
+      files[part] = new TextEncoder().encode(after);
+      changed = true;
+    }
+    if (!relsXml) continue;
+
+    let nextRels = relsXml;
+    for (const id of removedIds) {
+      if (remainingIds.has(id)) continue;
+      nextRels = removeRelationshipById(nextRels, id);
+      const rel = relsById.get(id);
+      if (rel && rel.targetMode !== "External") {
+        removedTargets.add(resolvePartPath(partDir, rel.target));
+      }
+    }
+    if (nextRels !== relsXml) {
+      files[relsPath] = new TextEncoder().encode(nextRels);
+    }
+  }
+
+  const deleted = deleteUnreferencedTargets(files, removedTargets);
+  if (deleted.size > 0) {
+    removeContentTypeOverrides(files, deleted);
+    changed = true;
+  }
+  if (removeUnusedMediaDefaults(files, ["svg", "wdp"])) {
+    changed = true;
+  }
+
+  return changed;
+}
+
+function deleteUnreferencedTargets(files, removedTargets) {
+  const remainingRefs = referencedInternalTargets(files);
+  const deleted = new Set();
+  for (const part of removedTargets) {
+    if (!part || remainingRefs.has(part) || files[part] === undefined) continue;
+    delete files[part];
+    const sidecar = relsPathFor(part);
+    if (files[sidecar] !== undefined) delete files[sidecar];
+    deleted.add(part);
+  }
+  return deleted;
+}
+
+function referencedInternalTargets(files) {
+  const refs = new Set();
+  for (const relsPath of Object.keys(files)) {
+    if (!relsPath.endsWith(".rels")) continue;
+    const dir = relsPath.replace(/\/?_rels\/[^/]+$/, "");
+    const owner =
+      dir === ""
+        ? relsPath.replace(/^_rels\/(.*)\.rels$/, "$1")
+        : `${dir}/${relsPath.replace(/^.*_rels\/(.*)\.rels$/, "$1")}`;
+    for (const rel of relsFor(files, owner)) {
+      if (rel.targetMode === "External") continue;
+      refs.add(resolvePartPath(dir, rel.target));
+    }
+  }
+  return refs;
+}
+
+function removeContentTypeOverrides(files, deletedParts) {
+  const before = readText(files, CONTENT_TYPES);
+  if (!before) return;
+  let after = before;
+  for (const part of deletedParts) {
+    after = after.replace(
+      new RegExp(
+        `<Override\\b(?=[^>]*\\bPartName="/${escapeRe(part)}")[^>]*?/>`,
+        "g",
+      ),
+      "",
+    );
+  }
+  if (after !== before) files[CONTENT_TYPES] = new TextEncoder().encode(after);
+}
+
+function removeUnusedMediaDefaults(files, exts) {
+  const before = readText(files, CONTENT_TYPES);
+  if (!before) return false;
+  let after = before;
+  for (const ext of exts) {
+    const hasPart = Object.keys(files).some((part) =>
+      part.toLowerCase().endsWith(`.${ext}`),
+    );
+    if (hasPart) continue;
+    after = after.replace(
+      new RegExp(`<Default\\b(?=[^>]*\\bExtension="${escapeRe(ext)}")[^>]*?/>`, "g"),
+      "",
+    );
+  }
+  if (after !== before) {
+    files[CONTENT_TYPES] = new TextEncoder().encode(after);
+    return true;
+  }
+  return false;
+}
+
+function relationshipIdsIn(xml) {
+  const ids = new Set();
+  for (const m of String(xml).matchAll(/\br:(?:id|embed|link)\s*=\s*"([^"]+)"/g)) {
+    ids.add(m[1]);
+  }
+  return ids;
+}
+
+function removeRelationshipById(xml, id) {
+  return xml.replace(
+    new RegExp(
+      `<Relationship\\b(?=[^>]*\\bId="${escapeRe(id)}")[^>]*?(?:/>|>[\\s\\S]*?</Relationship>)`,
+      "g",
+    ),
+    "",
+  );
+}
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");