@particle-academy/dark-slide 0.5.2

package/dist/index.cjs

@@ -0,0 +1,3534 @@
+'use strict';
+
+// src/exceptions.ts
+var SchemaException = class _SchemaException extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.name = "SchemaException";
+    this.errors = errors;
+    Object.setPrototypeOf(this, _SchemaException.prototype);
+  }
+};
+
+// src/helpers/emu.ts
+var EMU_PER_INCH = 914400;
+var DEFAULT_SLIDE_WIDTH = 9144e3;
+var DEFAULT_SLIDE_HEIGHT = 5143500;
+var Emu = {
+  EMU_PER_INCH,
+  DEFAULT_SLIDE_WIDTH,
+  DEFAULT_SLIDE_HEIGHT,
+  fromFracX(f, slideWidthEmu = DEFAULT_SLIDE_WIDTH) {
+    return Math.round(f * slideWidthEmu);
+  },
+  fromFracY(f, slideHeightEmu = DEFAULT_SLIDE_HEIGHT) {
+    return Math.round(f * slideHeightEmu);
+  },
+  toFracX(emu, slideWidthEmu = DEFAULT_SLIDE_WIDTH) {
+    return slideWidthEmu === 0 ? 0 : emu / slideWidthEmu;
+  },
+  toFracY(emu, slideHeightEmu = DEFAULT_SLIDE_HEIGHT) {
+    return slideHeightEmu === 0 ? 0 : emu / slideHeightEmu;
+  },
+  fromPt(pt) {
+    return Math.round(pt * (EMU_PER_INCH / 72));
+  },
+  hundredthsOfPoint(pt) {
+    return Math.round(pt * 100);
+  }
+};
+
+// src/reader/xml.ts
+function localName(name) {
+  const idx = name.indexOf(":");
+  return idx >= 0 ? name.slice(idx + 1) : name;
+}
+function unescapeXml(s) {
+  if (s.indexOf("&") < 0) return s;
+  return s.replace(/&(#x?[0-9a-fA-F]+|\w+);/g, (m, ent) => {
+    switch (ent) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      case "apos":
+        return "'";
+      default:
+        if (ent[0] === "#") {
+          const code = ent[1] === "x" || ent[1] === "X" ? parseInt(ent.slice(2), 16) : parseInt(ent.slice(1), 10);
+          return Number.isFinite(code) ? String.fromCodePoint(code) : m;
+        }
+        return m;
+    }
+  });
+}
+function findTagEnd(src, from) {
+  let quote = "";
+  for (let i = from; i < src.length; i++) {
+    const ch = src[i];
+    if (quote) {
+      if (ch === quote) quote = "";
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === ">") {
+      return i;
+    }
+  }
+  return src.length;
+}
+var ATTR_RE = /([^\s=/]+)\s*=\s*("([^"]*)"|'([^']*)')/g;
+function parseTag(inner) {
+  const trimmed = inner.trim();
+  let i = 0;
+  while (i < trimmed.length && !/\s/.test(trimmed[i])) i++;
+  const name = trimmed.slice(0, i);
+  const attrs = {};
+  const rest = trimmed.slice(i);
+  for (const m of rest.matchAll(ATTR_RE)) {
+    const key = localName(m[1]);
+    const value = unescapeXml(m[3] ?? m[4] ?? "");
+    attrs[key] = value;
+  }
+  return { name, attrs };
+}
+function parseXml(src) {
+  let i = 0;
+  const n = src.length;
+  const root = { name: "#root", attrs: {}, children: [], text: "" };
+  const stack = [root];
+  while (i < n) {
+    if (src[i] === "<") {
+      if (src.startsWith("<!--", i)) {
+        const end2 = src.indexOf("-->", i);
+        i = end2 < 0 ? n : end2 + 3;
+        continue;
+      }
+      if (src.startsWith("<![CDATA[", i)) {
+        const end2 = src.indexOf("]]>", i);
+        stack[stack.length - 1].text += src.slice(i + 9, end2 < 0 ? n : end2);
+        i = end2 < 0 ? n : end2 + 3;
+        continue;
+      }
+      if (src.startsWith("<?", i)) {
+        const end2 = src.indexOf("?>", i);
+        i = end2 < 0 ? n : end2 + 2;
+        continue;
+      }
+      if (src.startsWith("<!", i)) {
+        const end2 = src.indexOf(">", i);
+        i = end2 < 0 ? n : end2 + 1;
+        continue;
+      }
+      if (src[i + 1] === "/") {
+        const end2 = src.indexOf(">", i);
+        if (stack.length > 1) stack.pop();
+        i = end2 < 0 ? n : end2 + 1;
+        continue;
+      }
+      const end = findTagEnd(src, i + 1);
+      const tagContent = src.slice(i + 1, end);
+      const selfClosing = tagContent.endsWith("/");
+      const { name, attrs } = parseTag(selfClosing ? tagContent.slice(0, -1) : tagContent);
+      const node = { name: localName(name), attrs, children: [], text: "" };
+      stack[stack.length - 1].children.push(node);
+      if (!selfClosing) stack.push(node);
+      i = end + 1;
+    } else {
+      const next = src.indexOf("<", i);
+      const stop = next < 0 ? n : next;
+      stack[stack.length - 1].text += unescapeXml(src.slice(i, stop));
+      i = stop;
+    }
+  }
+  return root.children[0] ?? null;
+}
+function el(node, name) {
+  return node?.children.find((c) => c.name === name);
+}
+function at(node, name) {
+  return node?.attrs[name];
+}
+
+// src/zip/crc32.ts
+var TABLE = /* @__PURE__ */ (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (let i = 0; i < bytes.length; i++) {
+    crc = TABLE[(crc ^ bytes[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+
+// src/zip/zip-writer.ts
+var encoder = new TextEncoder();
+var DOS_TIME = 0;
+var DOS_DATE = 33;
+function zipSync(files) {
+  const localParts = [];
+  const centralParts = [];
+  let offset = 0;
+  for (const f of files) {
+    const nameBytes = encoder.encode(f.name);
+    const crc = crc32(f.data);
+    const size = f.data.length;
+    const lh = new Uint8Array(30 + nameBytes.length);
+    const ldv = new DataView(lh.buffer);
+    ldv.setUint32(0, 67324752, true);
+    ldv.setUint16(4, 20, true);
+    ldv.setUint16(6, 2048, true);
+    ldv.setUint16(8, 0, true);
+    ldv.setUint16(10, DOS_TIME, true);
+    ldv.setUint16(12, DOS_DATE, true);
+    ldv.setUint32(14, crc, true);
+    ldv.setUint32(18, size, true);
+    ldv.setUint32(22, size, true);
+    ldv.setUint16(26, nameBytes.length, true);
+    ldv.setUint16(28, 0, true);
+    lh.set(nameBytes, 30);
+    localParts.push(lh, f.data);
+    const cd = new Uint8Array(46 + nameBytes.length);
+    const cdv = new DataView(cd.buffer);
+    cdv.setUint32(0, 33639248, true);
+    cdv.setUint16(4, 20, true);
+    cdv.setUint16(6, 20, true);
+    cdv.setUint16(8, 2048, true);
+    cdv.setUint16(10, 0, true);
+    cdv.setUint16(12, DOS_TIME, true);
+    cdv.setUint16(14, DOS_DATE, true);
+    cdv.setUint32(16, crc, true);
+    cdv.setUint32(20, size, true);
+    cdv.setUint32(24, size, true);
+    cdv.setUint16(28, nameBytes.length, true);
+    cdv.setUint16(30, 0, true);
+    cdv.setUint16(32, 0, true);
+    cdv.setUint16(34, 0, true);
+    cdv.setUint16(36, 0, true);
+    cdv.setUint32(38, 0, true);
+    cdv.setUint32(42, offset, true);
+    cd.set(nameBytes, 46);
+    centralParts.push(cd);
+    offset += lh.length + f.data.length;
+  }
+  const localSize = offset;
+  const centralSize = centralParts.reduce((s, c) => s + c.length, 0);
+  const eocd = new Uint8Array(22);
+  const edv = new DataView(eocd.buffer);
+  edv.setUint32(0, 101010256, true);
+  edv.setUint16(4, 0, true);
+  edv.setUint16(6, 0, true);
+  edv.setUint16(8, files.length, true);
+  edv.setUint16(10, files.length, true);
+  edv.setUint32(12, centralSize, true);
+  edv.setUint32(16, localSize, true);
+  edv.setUint16(20, 0, true);
+  const out = new Uint8Array(localSize + centralSize + 22);
+  let p = 0;
+  for (const part of localParts) {
+    out.set(part, p);
+    p += part.length;
+  }
+  for (const part of centralParts) {
+    out.set(part, p);
+    p += part.length;
+  }
+  out.set(eocd, p);
+  return out;
+}
+
+// src/zip/inflate.ts
+var Tree = class {
+  constructor() {
+    // number of codes with a given bit length
+    this.table = new Uint16Array(16);
+    // symbols sorted by code
+    this.trans = new Uint16Array(288);
+  }
+};
+var LENGTH_BITS = new Uint8Array([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0
+]);
+var LENGTH_BASE = new Uint16Array([
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  13,
+  15,
+  17,
+  19,
+  23,
+  27,
+  31,
+  35,
+  43,
+  51,
+  59,
+  67,
+  83,
+  99,
+  115,
+  131,
+  163,
+  195,
+  227,
+  258
+]);
+var DIST_BITS = new Uint8Array([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13
+]);
+var DIST_BASE = new Uint16Array([
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577
+]);
+var CLC_INDEX = new Uint8Array([
+  16,
+  17,
+  18,
+  0,
+  8,
+  7,
+  9,
+  6,
+  10,
+  5,
+  11,
+  4,
+  12,
+  3,
+  13,
+  2,
+  14,
+  1,
+  15
+]);
+function buildFixedTrees(lt, dt) {
+  let i;
+  for (i = 0; i < 7; i++) lt.table[i] = 0;
+  lt.table[7] = 24;
+  lt.table[8] = 152;
+  lt.table[9] = 112;
+  for (i = 0; i < 24; i++) lt.trans[i] = 256 + i;
+  for (i = 0; i < 144; i++) lt.trans[24 + i] = i;
+  for (i = 0; i < 8; i++) lt.trans[24 + 144 + i] = 280 + i;
+  for (i = 0; i < 112; i++) lt.trans[24 + 144 + 8 + i] = 144 + i;
+  for (i = 0; i < 5; i++) dt.table[i] = 0;
+  dt.table[5] = 32;
+  for (i = 0; i < 32; i++) dt.trans[i] = i;
+}
+var OFFS = new Uint16Array(16);
+function buildTree(t, lengths, off, num) {
+  let i;
+  let sum = 0;
+  for (i = 0; i < 16; i++) t.table[i] = 0;
+  for (i = 0; i < num; i++) t.table[lengths[off + i]]++;
+  t.table[0] = 0;
+  for (i = 0; i < 16; i++) {
+    OFFS[i] = sum;
+    sum += t.table[i];
+  }
+  for (i = 0; i < num; i++) {
+    const len = lengths[off + i];
+    if (len) t.trans[OFFS[len]++] = i;
+  }
+}
+var Reader = class {
+  constructor(source) {
+    this.index = 0;
+    this.tag = 0;
+    this.bitcount = 0;
+    this.source = source;
+  }
+};
+function getBit(d) {
+  if (d.bitcount-- === 0) {
+    d.tag = d.source[d.index++];
+    d.bitcount = 7;
+  }
+  const bit = d.tag & 1;
+  d.tag >>>= 1;
+  return bit;
+}
+function readBits(d, num, base) {
+  if (!num) return base;
+  let val = 0;
+  for (let i = 0; i < num; i++) val |= getBit(d) << i;
+  return val + base;
+}
+function decodeSymbol(d, t) {
+  let sum = 0;
+  let cur = 0;
+  let len = 0;
+  do {
+    cur = 2 * cur + getBit(d);
+    len++;
+    sum += t.table[len];
+    cur -= t.table[len];
+  } while (cur >= 0);
+  return t.trans[sum + cur];
+}
+function decodeTrees(d, lt, dt) {
+  const lengths = new Uint8Array(288 + 32);
+  const hlit = readBits(d, 5, 257);
+  const hdist = readBits(d, 5, 1);
+  const hclen = readBits(d, 4, 4);
+  let i;
+  for (i = 0; i < 19; i++) lengths[i] = 0;
+  for (i = 0; i < hclen; i++) {
+    const clen = readBits(d, 3, 0);
+    lengths[CLC_INDEX[i]] = clen;
+  }
+  const codeTree = new Tree();
+  buildTree(codeTree, lengths, 0, 19);
+  for (let num = 0; num < hlit + hdist; ) {
+    const sym = decodeSymbol(d, codeTree);
+    switch (sym) {
+      case 16: {
+        const prev = lengths[num - 1];
+        for (let length = readBits(d, 2, 3); length; length--) lengths[num++] = prev;
+        break;
+      }
+      case 17:
+        for (let length = readBits(d, 3, 3); length; length--) lengths[num++] = 0;
+        break;
+      case 18:
+        for (let length = readBits(d, 7, 11); length; length--) lengths[num++] = 0;
+        break;
+      default:
+        lengths[num++] = sym;
+        break;
+    }
+  }
+  buildTree(lt, lengths, 0, hlit);
+  buildTree(dt, lengths, hlit, hdist);
+}
+var Out = class {
+  constructor() {
+    this.buf = new Uint8Array(1024);
+    this.len = 0;
+  }
+  push(b) {
+    if (this.len >= this.buf.length) {
+      const next = new Uint8Array(this.buf.length * 2);
+      next.set(this.buf);
+      this.buf = next;
+    }
+    this.buf[this.len++] = b;
+  }
+};
+function inflateBlockData(d, out, lt, dt) {
+  for (; ; ) {
+    const sym = decodeSymbol(d, lt);
+    if (sym === 256) return;
+    if (sym < 256) {
+      out.push(sym);
+    } else {
+      const lengthSym = sym - 257;
+      const length = readBits(d, LENGTH_BITS[lengthSym], LENGTH_BASE[lengthSym]);
+      const distSym = decodeSymbol(d, dt);
+      const dist = readBits(d, DIST_BITS[distSym], DIST_BASE[distSym]);
+      const offs = out.len - dist;
+      for (let i = 0; i < length; i++) out.push(out.buf[offs + i]);
+    }
+  }
+}
+function inflateUncompressedBlock(d, out) {
+  d.bitcount = 0;
+  let length = d.source[d.index + 1] * 256 + d.source[d.index];
+  d.index += 4;
+  for (; length; length--) out.push(d.source[d.index++]);
+}
+function inflateRaw(source) {
+  const d = new Reader(source);
+  const out = new Out();
+  const lt = new Tree();
+  const dt = new Tree();
+  let bfinal;
+  do {
+    bfinal = getBit(d);
+    const btype = readBits(d, 2, 0);
+    if (btype === 0) {
+      inflateUncompressedBlock(d, out);
+    } else if (btype === 1) {
+      buildFixedTrees(lt, dt);
+      inflateBlockData(d, out, lt, dt);
+    } else if (btype === 2) {
+      decodeTrees(d, lt, dt);
+      inflateBlockData(d, out, lt, dt);
+    } else {
+      throw new Error("dark-slide: invalid DEFLATE block type");
+    }
+  } while (!bfinal);
+  return out.buf.subarray(0, out.len);
+}
+
+// src/zip/zip-reader.ts
+var decoder = new TextDecoder();
+function unzipSync(data) {
+  const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let eocd = -1;
+  for (let i = data.length - 22; i >= 0; i--) {
+    if (dv.getUint32(i, true) === 101010256) {
+      eocd = i;
+      break;
+    }
+  }
+  if (eocd < 0) throw new Error("dark-slide: not a zip archive (no EOCD record)");
+  const count = dv.getUint16(eocd + 10, true);
+  let cd = dv.getUint32(eocd + 16, true);
+  const result = {};
+  for (let n = 0; n < count; n++) {
+    if (dv.getUint32(cd, true) !== 33639248) break;
+    const method = dv.getUint16(cd + 10, true);
+    const compSize = dv.getUint32(cd + 20, true);
+    const nameLen = dv.getUint16(cd + 28, true);
+    const extraLen = dv.getUint16(cd + 30, true);
+    const commentLen = dv.getUint16(cd + 32, true);
+    const localOffset = dv.getUint32(cd + 42, true);
+    const name = decoder.decode(data.subarray(cd + 46, cd + 46 + nameLen));
+    const lhNameLen = dv.getUint16(localOffset + 26, true);
+    const lhExtraLen = dv.getUint16(localOffset + 28, true);
+    const dataStart = localOffset + 30 + lhNameLen + lhExtraLen;
+    const raw = data.subarray(dataStart, dataStart + compSize);
+    let content;
+    if (method === 0) content = raw.slice();
+    else if (method === 8) content = inflateRaw(raw);
+    else throw new Error(`dark-slide: unsupported zip method ${method} for "${name}"`);
+    result[name] = content;
+    cd += 46 + nameLen + extraLen + commentLen;
+  }
+  return result;
+}
+
+// src/reader/pptx-reader.ts
+var DECODER = new TextDecoder();
+function base64Encode(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+  }
+  let bin = "";
+  for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+  return btoa(bin);
+}
+function basename(path) {
+  const parts = path.split("/");
+  return parts[parts.length - 1];
+}
+function dirname(path) {
+  const idx = path.lastIndexOf("/");
+  return idx < 0 ? "." : path.slice(0, idx);
+}
+function extension(path) {
+  const base = basename(path);
+  const idx = base.lastIndexOf(".");
+  return idx < 0 ? "" : base.slice(idx + 1).toLowerCase();
+}
+function descendant(node, name) {
+  if (!node) return void 0;
+  for (const child of node.children) {
+    if (child.name === name) return child;
+    const found = descendant(child, name);
+    if (found) return found;
+  }
+  return void 0;
+}
+function descendants(node, name) {
+  const out = [];
+  if (!node) return out;
+  for (const child of node.children) {
+    if (child.name === name) out.push(child);
+    out.push(...descendants(child, name));
+  }
+  return out;
+}
+function deepText(node) {
+  let s = node.text;
+  for (const child of node.children) s += deepText(child);
+  return s;
+}
+var PptxReader = class {
+  constructor() {
+    this.currentSlideRels = {};
+    this.parts = {};
+  }
+  /** Read a PPTX file's bytes into a Deck schema object. */
+  read(bytes) {
+    return this.fromBytes(bytes);
+  }
+  fromBytes(bytes) {
+    this.parts = unzipSync(bytes);
+    return this.extract();
+  }
+  getPart(name) {
+    const p = this.parts[name];
+    return p === void 0 ? false : DECODER.decode(p);
+  }
+  extract() {
+    const deck = {
+      id: "imported-" + (Math.floor(Date.now() / 1e3) & 16777215).toString(16),
+      title: this.readCoreTitle() ?? "Imported",
+      theme: { name: "imported" },
+      slides: []
+    };
+    const presentationRels = this.getPart("ppt/_rels/presentation.xml.rels");
+    if (presentationRels === false) {
+      return deck;
+    }
+    const slideTargets = this.extractSlideTargets(presentationRels);
+    slideTargets.forEach((slideTarget, i) => {
+      const slideXml = this.getPart("ppt/" + slideTarget);
+      if (slideXml === false) {
+        return;
+      }
+      const slideRels = this.getPart("ppt/" + dirname(slideTarget) + "/_rels/" + basename(slideTarget) + ".rels") || "";
+      const notes = this.readNotesFor(slideRels);
+      this.currentSlideRels = this.parseSlideRels(slideRels, slideTarget);
+      const slide = this.parseSlide(slideXml, "imported-slide-" + (i + 1), notes);
+      deck.slides.push(slide);
+    });
+    return deck;
+  }
+  parseSlideRels(relsXml, slideTargetRelative) {
+    if (relsXml === "") {
+      return {};
+    }
+    const root = parseXml(relsXml);
+    if (!root) {
+      return {};
+    }
+    const slideDirAbs = "ppt/" + dirname(slideTargetRelative);
+    const rels = {};
+    for (const r of descendants(root, "Relationship")) {
+      const id = at(r, "Id") ?? "";
+      const type = at(r, "Type") ?? "";
+      const target = at(r, "Target") ?? "";
+      const resolved = this.resolveRelTarget(slideDirAbs, target);
+      rels[id] = { type, target: resolved };
+    }
+    return rels;
+  }
+  resolveRelTarget(baseDir, target) {
+    if (target.startsWith("/")) {
+      return target.replace(/^\/+/, "");
+    }
+    const stack = baseDir.split("/");
+    for (const segment of target.split("/")) {
+      if (segment === "..") {
+        stack.pop();
+      } else if (segment !== "." && segment !== "") {
+        stack.push(segment);
+      }
+    }
+    return stack.join("/");
+  }
+  extractSlideTargets(relsXml) {
+    const targets = [];
+    const root = parseXml(relsXml);
+    if (!root) {
+      return [];
+    }
+    for (const r of descendants(root, "Relationship")) {
+      const type = at(r, "Type") ?? "";
+      if (type.endsWith("/slide")) {
+        targets.push(at(r, "Target") ?? "");
+      }
+    }
+    return targets;
+  }
+  readCoreTitle() {
+    const xml = this.getPart("docProps/core.xml");
+    if (xml === false) {
+      return null;
+    }
+    const root = parseXml(xml);
+    if (!root) {
+      return null;
+    }
+    const title = descendant(root, "title");
+    if (title) {
+      return deepText(title);
+    }
+    return null;
+  }
+  readNotesFor(slideRelsXml) {
+    if (slideRelsXml === "") {
+      return null;
+    }
+    const root = parseXml(slideRelsXml);
+    if (!root) {
+      return null;
+    }
+    for (const r of descendants(root, "Relationship")) {
+      if ((at(r, "Type") ?? "").endsWith("/notesSlide")) {
+        const target = at(r, "Target") ?? "";
+        const notesXml = this.getPart("ppt/" + target.replace(/\.\.\//g, "").replace(/^\/+/, ""));
+        if (notesXml === false) {
+          return null;
+        }
+        return this.parseNotesText(notesXml);
+      }
+    }
+    return null;
+  }
+  parseNotesText(xml) {
+    const root = parseXml(xml);
+    if (!root) {
+      return "";
+    }
+    const parts = [];
+    for (const t of descendants(root, "t")) {
+      parts.push(deepText(t));
+    }
+    return parts.join("\n");
+  }
+  parseSlide(xml, id, notes) {
+    const slide = {
+      id,
+      layout: "blank",
+      elements: []
+    };
+    if (notes !== null && notes !== "") {
+      slide.notes = notes;
+    }
+    const root = parseXml(xml);
+    if (!root) {
+      return slide;
+    }
+    const bg = this.parseBackground(root);
+    if (bg !== null) {
+      slide.background = bg;
+    }
+    for (const shape of descendants(root, "sp")) {
+      const element = this.parseShape(shape);
+      if (element !== null) {
+        slide.elements.push(element);
+      }
+    }
+    for (const pic of descendants(root, "pic")) {
+      const element = this.parsePic(pic);
+      if (element !== null) {
+        slide.elements.push(element);
+      }
+    }
+    for (const gf of descendants(root, "graphicFrame")) {
+      const element = this.parseGraphicFrame(gf);
+      if (element !== null) {
+        slide.elements.push(element);
+      }
+    }
+    return slide;
+  }
+  parseBackground(root) {
+    let bgPr;
+    for (const bg of descendants(root, "bg")) {
+      const inner = el(bg, "bgPr");
+      if (inner) {
+        bgPr = inner;
+        break;
+      }
+    }
+    if (!bgPr) {
+      return null;
+    }
+    const solidFill = descendant(bgPr, "solidFill");
+    const solid = solidFill ? descendant(solidFill, "srgbClr") : void 0;
+    if (solid) {
+      const hex = at(solid, "val") ?? "";
+      if (hex !== "") {
+        return { color: "#" + hex };
+      }
+    }
+    const grad = descendant(bgPr, "gradFill");
+    if (grad) {
+      const css = this.gradFillToCss(grad);
+      if (css !== null) {
+        return { gradient: css };
+      }
+    }
+    const blipFill = descendant(bgPr, "blipFill");
+    const blip = blipFill ? descendant(blipFill, "blip") : void 0;
+    if (blip) {
+      const rid = at(blip, "embed") ?? "";
+      if (rid !== "" && this.currentSlideRels[rid] !== void 0) {
+        const dataUri = this.readMediaAsDataUri(this.currentSlideRels[rid].target);
+        if (dataUri !== null) {
+          return { image: dataUri };
+        }
+      }
+    }
+    return null;
+  }
+  gradFillToCss(grad) {
+    const stops = descendants(grad, "gs");
+    if (stops.length === 0) {
+      return null;
+    }
+    const stopStrings = [];
+    for (const stop of stops) {
+      const pos = parseInt(at(stop, "pos") ?? "0", 10) || 0;
+      const pct = round1(pos / 1e3);
+      const color = descendant(stop, "srgbClr");
+      if (!color) {
+        continue;
+      }
+      const hex = at(color, "val") ?? "";
+      if (hex === "") {
+        continue;
+      }
+      stopStrings.push("#" + hex.toLowerCase() + " " + numToStr(pct) + "%");
+    }
+    if (stopStrings.length === 0) {
+      return null;
+    }
+    const lin = descendant(grad, "lin");
+    let angle = 180;
+    if (lin) {
+      const pptxAng = parseInt(at(lin, "ang") ?? "0", 10) || 0;
+      const deg = pptxAng / 6e4 + 90;
+      angle = Math.round((deg % 360 + 360) % 360);
+    }
+    return "linear-gradient(" + angle + "deg, " + stopStrings.join(", ") + ")";
+  }
+  readMediaAsDataUri(archivePath) {
+    const part = this.parts[archivePath];
+    if (part === void 0) {
+      return null;
+    }
+    const mime = this.guessMimeFromArchivePath(archivePath);
+    return "data:" + mime + ";base64," + base64Encode(part);
+  }
+  guessMimeFromArchivePath(path) {
+    switch (extension(path)) {
+      case "png":
+        return "image/png";
+      case "jpg":
+      case "jpeg":
+        return "image/jpeg";
+      case "gif":
+        return "image/gif";
+      case "svg":
+        return "image/svg+xml";
+      case "webp":
+        return "image/webp";
+      default:
+        return "application/octet-stream";
+    }
+  }
+  parseShape(sp) {
+    const xfrm = descendant(sp, "xfrm");
+    if (!xfrm) {
+      return null;
+    }
+    const offset = el(xfrm, "off");
+    const extent = el(xfrm, "ext");
+    if (!offset || !extent) {
+      return null;
+    }
+    const x = parseInt(at(offset, "x") ?? "0", 10) || 0;
+    const y = parseInt(at(offset, "y") ?? "0", 10) || 0;
+    const cx = parseInt(at(extent, "cx") ?? "0", 10) || 0;
+    const cy = parseInt(at(extent, "cy") ?? "0", 10) || 0;
+    const cNvPr = descendant(sp, "cNvPr");
+    const base = {
+      id: cNvPr ? at(cNvPr, "name") ?? "imported-" + randInt(1e3, 9999) : "imported-" + randInt(1e3, 9999),
+      x: Emu.toFracX(x),
+      y: Emu.toFracY(y),
+      w: Emu.toFracX(cx),
+      h: Emu.toFracY(cy)
+    };
+    const tBody = descendant(sp, "txBody");
+    const paragraphMarkdown = [];
+    let anyDecoration = false;
+    if (tBody) {
+      for (const p of descendants(tBody, "p")) {
+        const [md, decorated] = this.paragraphToMarkdown(p);
+        paragraphMarkdown.push(md);
+        anyDecoration = anyDecoration || decorated;
+      }
+    }
+    const prstGeom = descendant(sp, "prstGeom");
+    const prst = prstGeom ? at(prstGeom, "prst") ?? null : null;
+    const hasText = paragraphMarkdown.some((t) => t !== "");
+    if (hasText) {
+      return {
+        ...base,
+        type: "text",
+        content: paragraphMarkdown.join("\n"),
+        format: anyDecoration ? "markdown" : "plain"
+      };
+    }
+    let shapeKind;
+    switch (prst) {
+      case "rect":
+        shapeKind = "rect";
+        break;
+      case "roundRect":
+        shapeKind = "rounded-rect";
+        break;
+      case "ellipse":
+        shapeKind = "ellipse";
+        break;
+      case "triangle":
+        shapeKind = "triangle";
+        break;
+      case "line":
+        shapeKind = "line";
+        break;
+      case "rightArrow":
+        shapeKind = "arrow";
+        break;
+      default:
+        shapeKind = null;
+    }
+    if (shapeKind !== null) {
+      return { ...base, type: "shape", shape: shapeKind };
+    }
+    return null;
+  }
+  parsePic(pic) {
+    const xfrm = descendant(pic, "xfrm");
+    if (!xfrm) {
+      return null;
+    }
+    const offset = el(xfrm, "off");
+    const extent = el(xfrm, "ext");
+    if (!offset || !extent) {
+      return null;
+    }
+    let src = "";
+    const blip = descendant(pic, "blip");
+    if (blip) {
+      const rid = at(blip, "embed") ?? "";
+      if (rid !== "" && this.currentSlideRels[rid] !== void 0) {
+        const dataUri = this.readMediaAsDataUri(this.currentSlideRels[rid].target);
+        if (dataUri !== null) {
+          src = dataUri;
+        }
+      }
+    }
+    const cNvPr = descendant(pic, "cNvPr");
+    return {
+      id: cNvPr ? at(cNvPr, "name") ?? "imported-" + randInt(1e3, 9999) : "imported-" + randInt(1e3, 9999),
+      type: "image",
+      x: Emu.toFracX(parseInt(at(offset, "x") ?? "0", 10) || 0),
+      y: Emu.toFracY(parseInt(at(offset, "y") ?? "0", 10) || 0),
+      w: Emu.toFracX(parseInt(at(extent, "cx") ?? "0", 10) || 0),
+      h: Emu.toFracY(parseInt(at(extent, "cy") ?? "0", 10) || 0),
+      src,
+      fit: "contain"
+    };
+  }
+  parseGraphicFrame(gf) {
+    const xfrm = descendant(gf, "xfrm");
+    if (!xfrm) {
+      return null;
+    }
+    const offset = el(xfrm, "off");
+    const extent = el(xfrm, "ext");
+    if (!offset || !extent) {
+      return null;
+    }
+    const tbl = descendant(gf, "tbl");
+    if (!tbl) {
+      return null;
+    }
+    const rows = descendants(tbl, "tr");
+    if (rows.length === 0) {
+      return null;
+    }
+    const headerCells = descendants(rows[0], "tc");
+    const columns = [];
+    headerCells.forEach((cell, i) => {
+      const label = this.cellText(cell);
+      columns.push({ key: "col" + (i + 1), label });
+    });
+    const bodyRows = [];
+    for (let r = 1; r < rows.length; r++) {
+      const rowCells = descendants(rows[r], "tc");
+      const rowData = {};
+      columns.forEach((col, i) => {
+        const cell = rowCells[i];
+        if (cell !== void 0) {
+          rowData[col.key] = this.cellText(cell);
+        }
+      });
+      bodyRows.push(rowData);
+    }
+    const cNvPr = descendant(gf, "cNvPr");
+    return {
+      id: cNvPr ? at(cNvPr, "name") ?? "imported-table-" + randInt(1e3, 9999) : "imported-table-" + randInt(1e3, 9999),
+      type: "table",
+      x: Emu.toFracX(parseInt(at(offset, "x") ?? "0", 10) || 0),
+      y: Emu.toFracY(parseInt(at(offset, "y") ?? "0", 10) || 0),
+      w: Emu.toFracX(parseInt(at(extent, "cx") ?? "0", 10) || 0),
+      h: Emu.toFracY(parseInt(at(extent, "cy") ?? "0", 10) || 0),
+      columns,
+      rows: bodyRows
+    };
+  }
+  cellText(cell) {
+    const segments = [];
+    for (const t of descendants(cell, "t")) {
+      segments.push(deepText(t));
+    }
+    return segments.join("");
+  }
+  paragraphToMarkdown(p) {
+    const pPr = descendant(p, "pPr");
+    const bu = pPr ? descendant(pPr, "buChar") : void 0;
+    const isBullet = bu !== void 0;
+    const runs = descendants(p, "r");
+    if (runs.length === 0) {
+      return [isBullet ? "- " : "", isBullet];
+    }
+    const parsed = [];
+    let allBold = true;
+    let allItalic = true;
+    let anyNonEmpty = false;
+    for (const r of runs) {
+      const rPr = el(r, "rPr");
+      const tNode = el(r, "t");
+      const text = tNode ? deepText(tNode) : "";
+      let b = false;
+      let i = false;
+      let code = false;
+      if (rPr) {
+        b = (at(rPr, "b") ?? "0") === "1";
+        i = (at(rPr, "i") ?? "0") === "1";
+        const latin = el(rPr, "latin");
+        if (latin) {
+          const typeface = (at(latin, "typeface") ?? "").toLowerCase();
+          if (typeface.includes("consola") || typeface.includes("mono") || typeface.includes("courier")) {
+            code = true;
+          }
+        }
+      }
+      if (text !== "") {
+        anyNonEmpty = true;
+        if (!b) {
+          allBold = false;
+        }
+        if (!i) {
+          allItalic = false;
+        }
+      }
+      parsed.push({ text, b, i, code });
+    }
+    if (!anyNonEmpty) {
+      return [isBullet ? "- " : "", isBullet];
+    }
+    let line = "";
+    let anyDecoration = false;
+    for (const run of parsed) {
+      const text = run.text;
+      const emitBold = run.b && !allBold;
+      const emitItalic = run.i && !allItalic;
+      if (run.code) {
+        line += "`" + text + "`";
+        anyDecoration = true;
+      } else if (emitBold && emitItalic) {
+        line += "***" + text + "***";
+        anyDecoration = true;
+      } else if (emitBold) {
+        line += "**" + text + "**";
+        anyDecoration = true;
+      } else if (emitItalic) {
+        line += "*" + text + "*";
+        anyDecoration = true;
+      } else {
+        line += text;
+      }
+    }
+    if (isBullet) {
+      return ["- " + line, true];
+    }
+    return [line, anyDecoration];
+  }
+};
+function randInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function round1(x) {
+  return Math.round(x * 10) / 10;
+}
+function numToStr(n) {
+  return String(n);
+}
+
+// src/util.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNumeric(v) {
+  if (typeof v === "number") return Number.isFinite(v);
+  if (typeof v !== "string") return false;
+  return /^\s*[+-]?(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?$/.test(v);
+}
+function gettype(v) {
+  if (v === null || v === void 0) return "null";
+  if (Array.isArray(v)) return "array";
+  switch (typeof v) {
+    case "object":
+      return "object";
+    case "boolean":
+      return "boolean";
+    case "number":
+      return Number.isInteger(v) ? "integer" : "double";
+    case "string":
+      return "string";
+    default:
+      return typeof v;
+  }
+}
+function clone(v) {
+  return typeof structuredClone === "function" ? structuredClone(v) : JSON.parse(JSON.stringify(v));
+}
+
+// src/schema/schema.ts
+var Schema = {
+  VERSION: "0.1.0",
+  ELEMENT_TYPES: ["text", "image", "chart", "code", "table", "shape", "embed"],
+  SLIDE_LAYOUTS: [
+    "blank",
+    "title",
+    "title-content",
+    "two-column",
+    "section-divider",
+    "image-text",
+    "text-image",
+    "quote"
+  ],
+  SHAPE_KINDS: ["rect", "rounded-rect", "ellipse", "triangle", "line", "arrow"],
+  TEXT_FORMATS: ["markdown", "html", "plain"],
+  SLIDE_TRANSITION_KINDS: ["none", "fade", "slide", "zoom"],
+  SLIDE_TRANSITION_DIRECTIONS: ["left", "right", "up", "down"],
+  ANIMATION_EFFECTS: ["fade", "fly-in", "zoom", "wipe"],
+  ANIMATION_TRIGGERS: ["on-click", "with-prev", "after-prev"],
+  ANIMATION_DIRECTIONS: ["left", "right", "up", "down"],
+  ANIMATION_DEFAULT_DURATION_MS: 500,
+  DEFAULT_SLIDE_WIDTH_EMU: 9144e3,
+  DEFAULT_SLIDE_HEIGHT_EMU: 5143500,
+  DEFAULT_THEME_NAME: "default",
+  deckRequiredKeys() {
+    return ["id", "title", "slides", "theme"];
+  },
+  slideRequiredKeys() {
+    return ["id", "elements"];
+  },
+  elementRequiredKeys() {
+    return ["id", "type", "x", "y", "w", "h"];
+  },
+  jsonSchema() {
+    return {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      title: "DarkSlide Deck",
+      type: "object",
+      required: this.deckRequiredKeys(),
+      properties: {
+        id: { type: "string" },
+        title: { type: "string" },
+        theme: {
+          type: "object",
+          required: ["name"],
+          properties: {
+            name: { type: "string" },
+            aspectRatio: { type: "number" },
+            slideWidth: { type: "number" },
+            colors: {
+              type: "object",
+              properties: {
+                background: { type: "string" },
+                text: { type: "string" },
+                muted: { type: "string" },
+                accent: { type: "string" },
+                surface: { type: "string" }
+              }
+            },
+            fonts: {
+              type: "object",
+              properties: {
+                heading: { type: "string" },
+                body: { type: "string" },
+                mono: { type: "string" }
+              }
+            }
+          }
+        },
+        slides: {
+          type: "array",
+          items: {
+            type: "object",
+            required: this.slideRequiredKeys(),
+            properties: {
+              id: { type: "string" },
+              layout: { type: "string", enum: this.SLIDE_LAYOUTS },
+              elements: { type: "array", items: elementJsonSchema() },
+              background: {
+                type: "object",
+                properties: {
+                  color: { type: "string" },
+                  image: { type: "string" },
+                  imageFit: { type: "string", enum: ["contain", "cover", "fill"] },
+                  gradient: { type: "string" }
+                }
+              },
+              transition: {
+                type: "object",
+                properties: {
+                  kind: { type: "string", enum: this.SLIDE_TRANSITION_KINDS },
+                  duration: { type: "number" },
+                  direction: { type: "string", enum: this.SLIDE_TRANSITION_DIRECTIONS }
+                }
+              },
+              notes: { type: "string" },
+              metadata: { type: "object" }
+            }
+          }
+        },
+        metadata: { type: "object" }
+      }
+    };
+  }
+};
+function elementJsonSchema() {
+  return {
+    type: "object",
+    required: Schema.elementRequiredKeys(),
+    properties: {
+      id: { type: "string" },
+      type: { type: "string", enum: Schema.ELEMENT_TYPES },
+      x: { type: "number", minimum: 0, maximum: 1 },
+      y: { type: "number", minimum: 0, maximum: 1 },
+      w: { type: "number", minimum: 0, maximum: 1 },
+      h: { type: "number", minimum: 0, maximum: 1 },
+      rotation: { type: "number" },
+      z: { type: "integer" },
+      locked: { type: "boolean" },
+      hidden: { type: "boolean" },
+      href: { type: "string" },
+      content: { type: "string" },
+      format: { type: "string", enum: Schema.TEXT_FORMATS },
+      style: { type: "object" },
+      src: { type: "string" },
+      alt: { type: "string" },
+      fit: { type: "string", enum: ["contain", "cover", "fill", "scale-down"] },
+      shape: { type: "string", enum: Schema.SHAPE_KINDS },
+      fill: { type: "string" },
+      stroke: { type: "string" },
+      strokeWidth: { type: "number" },
+      dashed: { type: "boolean" },
+      radius: { type: "number" },
+      code: { type: "string" },
+      language: { type: "string" },
+      codeTheme: { type: "string" },
+      columns: { type: "array" },
+      rows: { type: "array" },
+      option: { type: "object" },
+      chartTheme: { type: "string" },
+      animation: {
+        type: "object",
+        required: ["effect"],
+        properties: {
+          effect: { type: "string", enum: Schema.ANIMATION_EFFECTS },
+          trigger: { type: "string", enum: Schema.ANIMATION_TRIGGERS },
+          direction: { type: "string", enum: Schema.ANIMATION_DIRECTIONS },
+          duration: { type: "number" },
+          delay: { type: "number" },
+          order: { type: "number" },
+          byParagraph: { type: "boolean" }
+        }
+      }
+    }
+  };
+}
+
+// src/schema/repairer.ts
+var Repairer = class {
+  constructor() {
+    this.idCounter = 0;
+  }
+  repair(deckInput) {
+    this.idCounter = 0;
+    const deck = isPlainObject(deckInput) ? clone(deckInput) : {};
+    deck.id ?? (deck.id = this.generateId("deck"));
+    deck.title ?? (deck.title = "Untitled");
+    deck.theme = this.repairTheme(deck.theme ?? null);
+    deck.slides = this.repairSlides(deck.slides ?? []);
+    return deck;
+  }
+  repairTheme(theme) {
+    if (!isPlainObject(theme)) return { name: Schema.DEFAULT_THEME_NAME };
+    theme.name ?? (theme.name = Schema.DEFAULT_THEME_NAME);
+    return theme;
+  }
+  repairSlides(slides) {
+    if (!Array.isArray(slides)) return [];
+    const out = [];
+    slides.forEach((slide, i) => {
+      if (!isPlainObject(slide)) return;
+      out.push(this.repairSlide(slide, i));
+    });
+    return out;
+  }
+  repairSlide(slide, index) {
+    slide.id ?? (slide.id = this.generateId("s", index));
+    slide.elements = this.repairElements(slide.elements ?? []);
+    if (slide.layout !== void 0 && !Schema.SLIDE_LAYOUTS.includes(slide.layout)) {
+      slide.layout = "blank";
+    }
+    return slide;
+  }
+  repairElements(elements) {
+    if (!Array.isArray(elements)) return [];
+    const out = [];
+    elements.forEach((element, i) => {
+      if (!isPlainObject(element)) return;
+      const repaired = this.repairElement(element, i);
+      if (repaired !== null) out.push(repaired);
+    });
+    return out;
+  }
+  repairElement(element, index) {
+    if (element.type === void 0 || !Schema.ELEMENT_TYPES.includes(element.type)) {
+      return null;
+    }
+    element.id ?? (element.id = this.generateId("e", index));
+    for (const coord of ["x", "y", "w", "h"]) {
+      element[coord] = this.clamp(isNumeric(element[coord]) ? Number(element[coord]) : 0, 0, 1);
+    }
+    if (element.w < 0.02) element.w = 0.02;
+    if (element.h < 0.02) element.h = 0.02;
+    switch (element.type) {
+      case "text":
+        element.content = typeof element.content === "string" ? element.content : "";
+        break;
+      case "image":
+        element.src = typeof element.src === "string" ? element.src : "";
+        break;
+      case "shape":
+        element.shape = typeof element.shape === "string" && Schema.SHAPE_KINDS.includes(element.shape) ? element.shape : "rect";
+        break;
+      case "code":
+        element.code = typeof element.code === "string" ? element.code : "";
+        break;
+    }
+    return element;
+  }
+  generateId(prefix, index = 0) {
+    this.idCounter++;
+    const t = (Math.floor(Date.now() / 1e3) & 16777215).toString(16);
+    const n = String(this.idCounter + index).padStart(3, "0");
+    return `${prefix}-${t}-${n}`;
+  }
+  clamp(v, min, max) {
+    if (!Number.isFinite(v)) return min;
+    return Math.max(min, Math.min(max, v));
+  }
+};
+
+// src/schema/validator.ts
+var Validator = class {
+  validate(deck) {
+    const errors = [];
+    const d = isPlainObject(deck) ? deck : {};
+    for (const key of Schema.deckRequiredKeys()) {
+      if (!(key in d)) errors.push(err(`/${key}`, key, "missing", null, `Deck must have an \`${key}\` field.`));
+    }
+    if (d.id !== void 0 && typeof d.id !== "string") {
+      errors.push(err("/id", "string", gettype(d.id), d.id, "Deck id must be a string."));
+    }
+    if (d.title !== void 0 && typeof d.title !== "string") {
+      errors.push(err("/title", "string", gettype(d.title), d.title, "Deck title must be a string."));
+    }
+    if (d.theme !== void 0) {
+      if (!isPlainObject(d.theme)) {
+        errors.push(err("/theme", "object", gettype(d.theme), d.theme, "Theme must be an object with at least a `name` field."));
+      } else if (d.theme.name === void 0) {
+        errors.push(err("/theme/name", "string", "missing", null, "Theme must have a name."));
+      }
+    }
+    if (d.slides !== void 0) {
+      if (!Array.isArray(d.slides)) {
+        errors.push(err("/slides", "array", gettype(d.slides), d.slides, "Slides must be a JSON array."));
+      } else {
+        d.slides.forEach((slide, i) => {
+          errors.push(...this.validateSlide(slide, `/slides/${i}`));
+        });
+      }
+    }
+    return errors;
+  }
+  validateSlide(slide, path) {
+    const errors = [];
+    if (!isPlainObject(slide)) {
+      return [err(path, "object", gettype(slide), slide, "Each slide must be a JSON object.")];
+    }
+    for (const key of Schema.slideRequiredKeys()) {
+      if (!(key in slide)) errors.push(err(`${path}/${key}`, key, "missing", null, `Slide must have a \`${key}\` field.`));
+    }
+    if (slide.id !== void 0 && typeof slide.id !== "string") {
+      errors.push(err(`${path}/id`, "string", gettype(slide.id), slide.id, "Slide id must be a string."));
+    }
+    if (slide.elements !== void 0) {
+      if (!Array.isArray(slide.elements)) {
+        errors.push(err(`${path}/elements`, "array", gettype(slide.elements), slide.elements, "Slide elements must be an array."));
+      } else {
+        slide.elements.forEach((element, i) => {
+          errors.push(...this.validateElement(element, `${path}/elements/${i}`));
+        });
+      }
+    }
+    if (slide.notes !== void 0 && typeof slide.notes !== "string") {
+      errors.push(err(`${path}/notes`, "string", gettype(slide.notes), slide.notes, "Slide notes must be a string."));
+    }
+    return errors;
+  }
+  validateElement(element, path) {
+    const errors = [];
+    if (!isPlainObject(element)) {
+      return [err(path, "object", gettype(element), element, "Each element must be a JSON object.")];
+    }
+    for (const key of Schema.elementRequiredKeys()) {
+      if (!(key in element)) errors.push(err(`${path}/${key}`, key, "missing", null, `Element must have a \`${key}\` field.`));
+    }
+    if (element.type !== void 0 && !Schema.ELEMENT_TYPES.includes(element.type)) {
+      errors.push(
+        err(
+          `${path}/type`,
+          "one of: " + Schema.ELEMENT_TYPES.join(" / "),
+          String(element.type),
+          element.type,
+          "Unknown element type \u2014 supported: " + Schema.ELEMENT_TYPES.join(", ")
+        )
+      );
+    }
+    for (const coord of ["x", "y", "w", "h"]) {
+      if (!(coord in element)) continue;
+      if (!isNumeric(element[coord])) {
+        errors.push(
+          err(
+            `${path}/${coord}`,
+            "number (0..1)",
+            gettype(element[coord]),
+            element[coord],
+            `Element ${coord} must be a number in the 0..1 range (slide-relative fraction).`
+          )
+        );
+      }
+    }
+    if (typeof element.type === "string") {
+      switch (element.type) {
+        case "text":
+          if (typeof element.content !== "string") {
+            errors.push(err(`${path}/content`, "string", gettype(element.content ?? null), element.content ?? null, "Text element must have a `content` string."));
+          }
+          break;
+        case "image":
+          if (typeof element.src !== "string") {
+            errors.push(err(`${path}/src`, "string (URL or data URI)", gettype(element.src ?? null), element.src ?? null, "Image element must have a `src` string."));
+          }
+          break;
+        case "shape":
+          if (!Schema.SHAPE_KINDS.includes(element.shape)) {
+            errors.push(err(`${path}/shape`, "one of: " + Schema.SHAPE_KINDS.join(" / "), String(element.shape ?? "missing"), element.shape ?? null, "Shape element must specify a known `shape` kind."));
+          }
+          break;
+        case "code":
+          if (typeof element.code !== "string") {
+            errors.push(err(`${path}/code`, "string", gettype(element.code ?? null), element.code ?? null, "Code element must have a `code` string."));
+          }
+          break;
+      }
+    }
+    return errors;
+  }
+};
+function err(path, expected, got, value, hint) {
+  return { path, expected, got, value, hint };
+}
+
+// src/helpers/chart-translator.ts
+var SUPPORTED_TYPES = ["bar", "line", "pie", "scatter"];
+var isScalar = (v) => typeof v === "number" || typeof v === "string" || typeof v === "boolean";
+var ChartTranslator = {
+  SUPPORTED_TYPES,
+  translate(option) {
+    const rawSeries = extractSeries(option);
+    if (rawSeries.length === 0) return null;
+    let categories = extractCategories(option);
+    const series = [];
+    let kind = null;
+    for (const raw of rawSeries) {
+      if (!isPlainObject(raw)) continue;
+      const type = typeof raw.type === "string" ? raw.type.toLowerCase() : "bar";
+      if (!SUPPORTED_TYPES.includes(type)) return null;
+      const normalised = normaliseSeries(raw, type);
+      if (normalised === null) return null;
+      kind ?? (kind = type);
+      series.push(normalised);
+      if (type === "pie" && categories.length === 0) {
+        categories = pieCategories(raw);
+      }
+    }
+    if (series.length === 0 || kind === null) return null;
+    return { kind, title: extractTitle(option), categories, series };
+  }
+};
+function extractSeries(option) {
+  const series = option?.series ?? null;
+  if (Array.isArray(series)) return series;
+  if (isPlainObject(series) && Object.keys(series).length > 0) return [series];
+  return [];
+}
+function extractCategories(option) {
+  let candidates = null;
+  const xAxis = option?.xAxis ?? null;
+  if (Array.isArray(xAxis)) {
+    candidates = isPlainObject(xAxis[0]) ? xAxis[0].data : xAxis.data;
+  } else if (isPlainObject(xAxis)) {
+    candidates = xAxis.data;
+  }
+  if (!Array.isArray(candidates)) candidates = option?.categories ?? null;
+  if (!Array.isArray(candidates)) return [];
+  const out = [];
+  for (const value of candidates) {
+    if (isScalar(value)) out.push(String(value));
+  }
+  return out;
+}
+function extractTitle(option) {
+  const title = option?.title ?? null;
+  if (isPlainObject(title)) {
+    const text = title.text ?? title[0]?.text ?? null;
+    if (typeof text === "string") return text;
+  }
+  if (Array.isArray(title)) {
+    const text = title[0]?.text ?? null;
+    if (typeof text === "string") return text;
+  }
+  if (typeof title === "string") return title;
+  return "";
+}
+function normaliseSeries(raw, type) {
+  const name = isScalar(raw.name) ? String(raw.name) : "";
+  const data = raw.data ?? null;
+  if (!Array.isArray(data)) return null;
+  const values = [];
+  const points = [];
+  for (const point of data) {
+    if (type === "scatter") {
+      const xy = scatterPoint(point);
+      if (xy !== null) points.push(xy);
+      continue;
+    }
+    values.push(numericValue(point));
+  }
+  if (type === "scatter" && points.length === 0) return null;
+  if (type !== "scatter" && values.length === 0) return null;
+  const area = type === "line" && raw.areaStyle !== void 0;
+  return { type, name, values, smooth: !!raw.smooth, area, points };
+}
+function numericValue(point) {
+  if (isNumeric(point)) return Number(point);
+  if (isPlainObject(point) && isNumeric(point.value)) return Number(point.value);
+  return 0;
+}
+function scatterPoint(point) {
+  let pair = point;
+  if (isPlainObject(point) && Array.isArray(point.value)) pair = point.value;
+  if (Array.isArray(pair) && pair.length >= 2 && isNumeric(pair[0]) && isNumeric(pair[1])) {
+    return { x: Number(pair[0]), y: Number(pair[1]) };
+  }
+  return null;
+}
+function pieCategories(raw) {
+  const data = raw.data ?? null;
+  if (!Array.isArray(data)) return [];
+  return data.map(
+    (point, i) => isPlainObject(point) && isScalar(point.name) ? String(point.name) : `Slice ${i + 1}`
+  );
+}
+
+// src/helpers/color.ts
+var NAMED = {
+  black: "000000",
+  white: "FFFFFF",
+  red: "FF0000",
+  green: "008000",
+  blue: "0000FF",
+  yellow: "FFFF00",
+  cyan: "00FFFF",
+  magenta: "FF00FF",
+  gray: "808080",
+  grey: "808080",
+  silver: "C0C0C0",
+  maroon: "800000",
+  olive: "808000",
+  lime: "00FF00",
+  aqua: "00FFFF",
+  teal: "008080",
+  navy: "000080",
+  fuchsia: "FF00FF",
+  purple: "800080",
+  orange: "FFA500"
+};
+var Color = {
+  parse(color, fallbackHex = "000000") {
+    if (color === null || color === void 0 || color === "") return [fallbackHex, 1e5];
+    const c = color.trim();
+    if (c === "transparent" || c === "none") return [fallbackHex, 0];
+    let m = /^#([0-9a-fA-F]{3})$/.exec(c);
+    if (m) {
+      const h = m[1];
+      const hex = (h[0] + h[0] + h[1] + h[1] + h[2] + h[2]).toUpperCase();
+      return [hex, 1e5];
+    }
+    m = /^#([0-9a-fA-F]{6})$/.exec(c);
+    if (m) return [m[1].toUpperCase(), 1e5];
+    m = /^#([0-9a-fA-F]{8})$/.exec(c);
+    if (m) {
+      const hex = m[1].slice(0, 6).toUpperCase();
+      const a = parseInt(m[1].slice(6, 8), 16);
+      return [hex, Math.round(a / 255 * 1e5)];
+    }
+    m = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([0-9.]+)\s*)?\)$/i.exec(c);
+    if (m) {
+      const r = parseInt(m[1], 10);
+      const g = parseInt(m[2], 10);
+      const b = parseInt(m[3], 10);
+      const a = m[4] !== void 0 ? parseFloat(m[4]) : 1;
+      const hex = [r, g, b].map((n) => n.toString(16).padStart(2, "0")).join("").toUpperCase();
+      return [hex, Math.round(a * 1e5)];
+    }
+    const named = NAMED[c.toLowerCase()];
+    if (named !== void 0) return [named, 1e5];
+    return [fallbackHex, 1e5];
+  }
+};
+
+// src/helpers/markdown-inline.ts
+var isWordChar = (ch) => /[a-zA-Z0-9_]/.test(ch);
+var MarkdownInline = {
+  tokenize(text) {
+    const runs = [];
+    let i = 0;
+    const len = text.length;
+    let buf = "";
+    let b = false;
+    let it = false;
+    const code = false;
+    const flush = () => {
+      if (buf !== "") {
+        runs.push({ text: buf, b, i: it, code });
+        buf = "";
+      }
+    };
+    while (i < len) {
+      const c = text[i];
+      const next2 = text.slice(i, i + 2);
+      if (c === "`" && !code) {
+        flush();
+        const end = text.indexOf("`", i + 1);
+        if (end === -1) {
+          buf += text.slice(i);
+          i = len;
+          continue;
+        }
+        runs.push({ text: text.slice(i + 1, end), b, i: it, code: true });
+        i = end + 1;
+        continue;
+      }
+      if (next2 === "**" || next2 === "__") {
+        flush();
+        b = !b;
+        i += 2;
+        continue;
+      }
+      if ((c === "*" || c === "_") && !code) {
+        const prev = i > 0 ? text[i - 1] : " ";
+        if (it && isWordChar(prev) || !it) {
+          if (!it) {
+            if (!isWordChar(prev) || prev === " ") {
+              flush();
+              it = true;
+              i++;
+              continue;
+            }
+          } else {
+            flush();
+            it = false;
+            i++;
+            continue;
+          }
+        }
+      }
+      buf += c;
+      i++;
+    }
+    flush();
+    if (runs.length === 0) {
+      runs.push({ text: "", b: false, i: false, code: false });
+    }
+    return runs;
+  },
+  /** [isBullet, contentWithoutMarker]. */
+  bulletPrefix(line) {
+    if (line.startsWith("- ") || line.startsWith("* ")) return [true, line.slice(2)];
+    return [false, line];
+  },
+  /** [level (1..6, 0=none), contentWithoutMarker]. */
+  headingPrefix(line) {
+    const m = /^(#{1,6})\s+(.*)$/.exec(line);
+    if (m) return [m[1].length, m[2]];
+    return [0, line];
+  }
+};
+
+// src/helpers/syntax-highlighter.ts
+var S = (re) => new RegExp(re.source, "sy");
+var C_LIKE = {
+  comment: S(/\/\/[^\n]*|\/\*.*?\*\//),
+  string: S(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`/),
+  number: S(/\b\d+(?:\.\d+)?\b/),
+  word: S(/[A-Za-z_$][A-Za-z0-9_$]*/),
+  punctuation: S(/[{}\[\]();,]/)
+};
+function config(lang) {
+  if (lang === null) return null;
+  switch (lang) {
+    case "javascript":
+    case "typescript":
+      return {
+        patterns: C_LIKE,
+        keywords: ["const", "let", "var", "function", "return", "if", "else", "for", "while", "do", "switch", "case", "break", "continue", "new", "class", "extends", "implements", "interface", "type", "enum", "import", "export", "from", "as", "default", "async", "await", "try", "catch", "finally", "throw", "typeof", "instanceof", "in", "of", "this", "super", "null", "undefined", "true", "false", "void", "never", "any", "unknown", "string", "number", "boolean", "object"],
+        builtins: ["console", "Math", "JSON", "Object", "Array", "String", "Number", "Boolean", "Promise", "Map", "Set", "Date", "Error", "document", "window", "globalThis", "require", "module", "process"]
+      };
+    case "php":
+      return {
+        patterns: {
+          comment: S(/\/\/[^\n]*|#[^\n]*|\/\*.*?\*\//),
+          string: S(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/),
+          number: S(/\b\d+(?:\.\d+)?\b/),
+          word: S(/\$?[A-Za-z_][A-Za-z0-9_]*/),
+          punctuation: S(/[{}\[\]();,]/)
+        },
+        keywords: ["abstract", "and", "array", "as", "break", "callable", "case", "catch", "class", "clone", "const", "continue", "declare", "default", "do", "echo", "else", "elseif", "empty", "enddeclare", "endfor", "endforeach", "endif", "endswitch", "endwhile", "enum", "extends", "final", "finally", "fn", "for", "foreach", "function", "global", "goto", "if", "implements", "include", "include_once", "instanceof", "insteadof", "interface", "isset", "list", "match", "namespace", "new", "null", "or", "private", "protected", "public", "readonly", "require", "require_once", "return", "static", "switch", "throw", "trait", "try", "unset", "use", "var", "while", "xor", "yield", "true", "false", "self", "parent", "this"],
+        builtins: ["__construct", "__toString", "__invoke", "array_map", "array_filter", "array_reduce", "array_keys", "array_values", "array_merge", "count", "strlen", "str_replace", "str_starts_with", "str_ends_with", "str_contains", "substr", "sprintf", "printf", "json_encode", "json_decode"]
+      };
+    case "json":
+      return {
+        patterns: {
+          string: S(/"(?:[^"\\]|\\.)*"/),
+          number: S(/-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/),
+          word: S(/[A-Za-z_][A-Za-z0-9_]*/),
+          punctuation: S(/[{}\[\]:,]/)
+        },
+        keywords: ["true", "false", "null"],
+        builtins: []
+      };
+    case "bash":
+      return {
+        patterns: {
+          comment: S(/#[^\n]*/),
+          string: S(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/),
+          number: S(/\b\d+\b/),
+          word: S(/[A-Za-z_][A-Za-z0-9_]*/),
+          punctuation: S(/[{}\[\]();|&]/)
+        },
+        keywords: ["if", "then", "else", "elif", "fi", "for", "while", "do", "done", "case", "esac", "in", "function", "return", "break", "continue", "export", "local", "readonly", "unset"],
+        builtins: ["echo", "printf", "cd", "pwd", "ls", "cp", "mv", "rm", "mkdir", "touch", "cat", "grep", "sed", "awk", "curl", "wget", "git", "npm", "composer", "php", "node"]
+      };
+    case "css":
+      return {
+        patterns: {
+          comment: S(/\/\*.*?\*\//),
+          string: S(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/),
+          number: S(/-?\d+(?:\.\d+)?(?:px|em|rem|%|vw|vh|deg)?/),
+          word: S(/[\-A-Za-z_][\-A-Za-z0-9_]*/),
+          punctuation: S(/[{};:,]/)
+        },
+        keywords: ["important", "inherit", "initial", "unset", "auto", "none"],
+        builtins: []
+      };
+    case "python":
+      return {
+        patterns: {
+          comment: S(/#[^\n]*/),
+          string: S(/"""[\s\S]*?"""|'''[\s\S]*?'''|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/),
+          number: S(/\b\d+(?:\.\d+)?\b/),
+          word: S(/[A-Za-z_][A-Za-z0-9_]*/),
+          punctuation: S(/[{}\[\]():,]/)
+        },
+        keywords: ["and", "as", "assert", "async", "await", "break", "class", "continue", "def", "del", "elif", "else", "except", "finally", "for", "from", "global", "if", "import", "in", "is", "lambda", "nonlocal", "not", "or", "pass", "raise", "return", "try", "while", "with", "yield", "True", "False", "None"],
+        builtins: ["print", "len", "range", "list", "dict", "set", "tuple", "str", "int", "float", "bool", "open", "input", "enumerate", "zip", "map", "filter", "sorted", "reversed", "sum", "min", "max", "abs", "round"]
+      };
+    case "html":
+      return {
+        patterns: {
+          comment: S(/<!--.*?-->/),
+          string: S(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/),
+          keyword: S(/<\/?[A-Za-z][A-Za-z0-9-]*/),
+          punctuation: S(/>|\/>|=/)
+        },
+        keywords: [],
+        builtins: []
+      };
+    default:
+      return null;
+  }
+}
+function normalizeLanguage(language) {
+  if (language === null || language === void 0) return null;
+  const lang = language.toLowerCase().trim();
+  switch (lang) {
+    case "js":
+      return "javascript";
+    case "ts":
+      return "typescript";
+    case "jsx":
+    case "tsx":
+      return "typescript";
+    case "sh":
+    case "shell":
+    case "bash":
+    case "zsh":
+      return "bash";
+    case "py":
+      return "python";
+    case "xml":
+      return "html";
+    default:
+      return lang;
+  }
+}
+var SyntaxHighlighter = {
+  tokenize(code, language) {
+    const lang = normalizeLanguage(language);
+    const cfg = config(lang);
+    if (cfg === null) return [{ text: code, kind: "plain" }];
+    const tokens = [];
+    let offset = 0;
+    const len = code.length;
+    const keywords = new Set(cfg.keywords);
+    const builtins = new Set(cfg.builtins);
+    while (offset < len) {
+      let bestKind = null;
+      let bestLen = 0;
+      for (const [kind2, re] of Object.entries(cfg.patterns)) {
+        re.lastIndex = offset;
+        const m = re.exec(code);
+        if (m && m.index === offset) {
+          const matchLen = m[0].length;
+          if (matchLen > bestLen) {
+            bestLen = matchLen;
+            bestKind = kind2;
+          }
+        }
+      }
+      if (bestKind === null || bestLen === 0) {
+        tokens.push({ text: code[offset], kind: "plain" });
+        offset++;
+        continue;
+      }
+      const text = code.slice(offset, offset + bestLen);
+      let kind = bestKind;
+      if (kind === "word") {
+        if (keywords.has(text)) kind = "keyword";
+        else if (builtins.has(text)) kind = "builtin";
+        else kind = "plain";
+      }
+      tokens.push({ text, kind });
+      offset += bestLen;
+    }
+    return coalesce(tokens);
+  },
+  colorFor(kind) {
+    switch (kind) {
+      case "keyword":
+        return "C084FC";
+      case "string":
+        return "86EFAC";
+      case "comment":
+        return "64748B";
+      case "number":
+        return "FBBF24";
+      case "builtin":
+        return "67E8F9";
+      case "punctuation":
+        return "CBD5E1";
+      default:
+        return "F8FAFC";
+    }
+  },
+  supportedLanguages() {
+    return ["javascript", "typescript", "jsx", "tsx", "php", "json", "bash", "shell", "css", "python", "html", "xml"];
+  }
+};
+function coalesce(tokens) {
+  const out = [];
+  for (const t of tokens) {
+    const last = out[out.length - 1];
+    if (last && last.kind === t.kind) {
+      last.text += t.text;
+      continue;
+    }
+    out.push({ ...t });
+  }
+  return out;
+}
+
+// src/helpers/xml.ts
+var Xml = {
+  text(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  },
+  attr(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  },
+  declaration(standalone = true) {
+    const sa = standalone ? ' standalone="yes"' : "";
+    return `<?xml version="1.0" encoding="UTF-8"${sa}?>
+`;
+  }
+};
+
+// src/writer/pptx-writer.ts
+var NS_CHART = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+var LAYOUT_ORDER = [
+  "blank",
+  "title",
+  "title-content",
+  "two-column",
+  "section-divider",
+  "image-text",
+  "text-image",
+  "quote"
+];
+var CHART_PALETTE = ["8B5CF6", "EC4899", "06B6D4", "F59E0B", "10B981", "3B82F6", "EF4444", "A855F7"];
+var ENCODER = new TextEncoder();
+function base64Decode(b64) {
+  if (typeof Buffer !== "undefined") {
+    const buf = Buffer.from(b64, "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function toInt(v) {
+  const n = typeof v === "number" ? v : parseFloat(String(v));
+  if (!Number.isFinite(n)) return 0;
+  return Math.trunc(n);
+}
+var PptxWriter = class {
+  constructor(tempDir = null, allowHttpImages = false) {
+    this.tempDir = tempDir;
+    this.allowHttpImages = allowHttpImages;
+    this.mediaCounter = 0;
+    this.chartCounter = 0;
+    /** Ordered list of media files queued for the archive. */
+    this.mediaFiles = [];
+    /** Ordered list of chart part XML queued for the archive. */
+    this.chartFiles = [];
+    this.themeAccent = "8B5CF6";
+    this.tnId = 0;
+    this.pendingSlideRels = {};
+  }
+  write() {
+    throw new Error("PptxWriter.write is Node-only; use Agent.write");
+  }
+  toBytes(deck) {
+    this.mediaCounter = 0;
+    this.chartCounter = 0;
+    this.mediaFiles = [];
+    this.chartFiles = [];
+    this.pendingSlideRels = {};
+    [this.themeAccent] = Color.parse(deck?.theme?.colors?.accent ?? "#8B5CF6", "8B5CF6");
+    const slides = deck?.slides ?? [];
+    const slideCount = slides.length;
+    const files = [];
+    const add = (name, content) => {
+      files.push({ name, data: typeof content === "string" ? ENCODER.encode(content) : content });
+    };
+    const slidesXml = {};
+    const notesSlidesXml = {};
+    slides.forEach((slide, i) => {
+      const oneBased = i + 1;
+      slidesXml[oneBased] = this.buildSlideXml(slide, oneBased, deck);
+      if (slide && slide.notes) {
+        notesSlidesXml[oneBased] = this.buildNotesSlideXml(slide, oneBased);
+      }
+    });
+    const notesIds = Object.keys(notesSlidesXml).map((k) => parseInt(k, 10));
+    const chartPartPaths = this.chartFiles.map((c) => c.path);
+    add("[Content_Types].xml", this.buildContentTypes(slideCount, notesIds, chartPartPaths));
+    add("_rels/.rels", this.buildTopRels());
+    add("docProps/core.xml", this.buildCoreProps(deck));
+    add("docProps/app.xml", this.buildAppProps(slideCount));
+    add("ppt/presentation.xml", this.buildPresentation(slideCount));
+    add("ppt/_rels/presentation.xml.rels", this.buildPresentationRels(slideCount));
+    add("ppt/theme/theme1.xml", this.buildTheme(deck));
+    add("ppt/slideMasters/slideMaster1.xml", this.buildSlideMaster());
+    add("ppt/slideMasters/_rels/slideMaster1.xml.rels", this.buildSlideMasterRels());
+    LAYOUT_ORDER.forEach((layoutName, idx) => {
+      const n = idx + 1;
+      add(`ppt/slideLayouts/slideLayout${n}.xml`, this.buildSlideLayout(layoutName));
+      add(`ppt/slideLayouts/_rels/slideLayout${n}.xml.rels`, this.buildSlideLayoutRels());
+    });
+    for (let i = 1; i <= slideCount; i++) {
+      const xml = slidesXml[i];
+      const layoutNum = this.layoutNumberFor(slides[i - 1]?.layout ?? null);
+      add(`ppt/slides/slide${i}.xml`, xml);
+      add(`ppt/slides/_rels/slide${i}.xml.rels`, this.buildSlideRels(i, notesSlidesXml[i] !== void 0, layoutNum));
+    }
+    for (const i of notesIds) {
+      add(`ppt/notesSlides/notesSlide${i}.xml`, notesSlidesXml[i]);
+      add(`ppt/notesSlides/_rels/notesSlide${i}.xml.rels`, this.buildNotesSlideRels(i));
+    }
+    for (const chart of this.chartFiles) {
+      add(chart.path, chart.xml);
+    }
+    for (const media of this.mediaFiles) {
+      add(media.path, media.bytes);
+    }
+    return zipSync(files);
+  }
+  // ─── Top-level parts ───────────────────────────────────────────────────
+  buildContentTypes(slideCount, notesSlideIds, chartParts) {
+    let slideOverrides = "";
+    for (let i = 1; i <= slideCount; i++) {
+      slideOverrides += '<Override PartName="/ppt/slides/slide' + i + '.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.slide+xml"/>';
+    }
+    let layoutOverrides = "";
+    LAYOUT_ORDER.forEach((_, idx) => {
+      const n = idx + 1;
+      layoutOverrides += '<Override PartName="/ppt/slideLayouts/slideLayout' + n + '.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml"/>';
+    });
+    let notesOverrides = "";
+    for (const i of notesSlideIds) {
+      notesOverrides += '<Override PartName="/ppt/notesSlides/notesSlide' + i + '.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml"/>';
+    }
+    let chartOverrides = "";
+    for (const archivePath of chartParts) {
+      chartOverrides += '<Override PartName="/' + archivePath + '" ContentType="application/vnd.openxmlformats-officedocument.drawingml.chart+xml"/>';
+    }
+    const extensionDefaults = '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Default Extension="png" ContentType="image/png"/><Default Extension="jpg" ContentType="image/jpeg"/><Default Extension="jpeg" ContentType="image/jpeg"/><Default Extension="gif" ContentType="image/gif"/><Default Extension="svg" ContentType="image/svg+xml"/><Default Extension="webp" ContentType="image/webp"/>';
+    return Xml.declaration() + '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">' + extensionDefaults + '<Override PartName="/ppt/presentation.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml"/><Override PartName="/ppt/slideMasters/slideMaster1.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml"/>' + layoutOverrides + '<Override PartName="/ppt/theme/theme1.xml" ContentType="application/vnd.openxmlformats-officedocument.theme+xml"/>' + slideOverrides + notesOverrides + chartOverrides + '<Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/><Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/></Types>';
+  }
+  buildTopRels() {
+    return Xml.declaration() + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="ppt/presentation.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/><Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/></Relationships>';
+  }
+  buildCoreProps(deck) {
+    const title = Xml.text(String(deck?.title ?? "Untitled"));
+    const author = deck?.metadata?.author !== void 0 && deck?.metadata?.author !== null ? Xml.text(String(deck.metadata.author)) : "Dark Slide";
+    const now = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+    return Xml.declaration() + `<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><dc:title>${title}</dc:title><dc:creator>${author}</dc:creator><cp:lastModifiedBy>${author}</cp:lastModifiedBy><dcterms:created xsi:type="dcterms:W3CDTF">${now}</dcterms:created><dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified></cp:coreProperties>`;
+  }
+  buildAppProps(slideCount) {
+    return Xml.declaration() + `<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"><Application>DarkSlide</Application><AppVersion>0.4.0</AppVersion><Slides>${slideCount}</Slides></Properties>`;
+  }
+  // ─── presentation.xml ──────────────────────────────────────────────────
+  buildPresentation(slideCount) {
+    let sldIdLst = "";
+    for (let i = 1; i <= slideCount; i++) {
+      const id = 256 + (i - 1);
+      sldIdLst += '<p:sldId id="' + id + '" r:id="rId' + (i + 1) + '"/>';
+    }
+    const slideMasterRid = "rId" + (slideCount + 2);
+    return Xml.declaration() + '<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" saveSubsetFonts="1"><p:sldMasterIdLst><p:sldMasterId id="2147483648" r:id="' + slideMasterRid + '"/></p:sldMasterIdLst><p:sldIdLst>' + sldIdLst + '</p:sldIdLst><p:sldSz cx="' + Emu.DEFAULT_SLIDE_WIDTH + '" cy="' + Emu.DEFAULT_SLIDE_HEIGHT + '" type="screen16x9"/><p:notesSz cx="' + Emu.DEFAULT_SLIDE_HEIGHT + '" cy="' + Emu.DEFAULT_SLIDE_WIDTH + '"/></p:presentation>';
+  }
+  buildPresentationRels(slideCount) {
+    let rels = '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" Target="theme/theme1.xml"/>';
+    for (let i = 1; i <= slideCount; i++) {
+      rels += '<Relationship Id="rId' + (i + 1) + '" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide" Target="slides/slide' + i + '.xml"/>';
+    }
+    rels += '<Relationship Id="rId' + (slideCount + 2) + '" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster" Target="slideMasters/slideMaster1.xml"/>';
+    return Xml.declaration() + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">' + rels + "</Relationships>";
+  }
+  // ─── theme / master / layout ───────────────────────────────────────────
+  buildTheme(deck) {
+    const colors = deck?.theme?.colors ?? {};
+    const [bg] = Color.parse(colors.background ?? "#FFFFFF", "FFFFFF");
+    const [text] = Color.parse(colors.text ?? "#0F172A", "0F172A");
+    const [accent] = Color.parse(colors.accent ?? "#8B5CF6", "8B5CF6");
+    const [muted] = Color.parse(colors.muted ?? "#44546A", "44546A");
+    const [surface] = Color.parse(colors.surface ?? "#E7E6E6", "E7E6E6");
+    const heading = Xml.attr(String(deck?.theme?.fonts?.heading ?? "Calibri"));
+    const body = Xml.attr(String(deck?.theme?.fonts?.body ?? "Calibri"));
+    const palette = [...CHART_PALETTE];
+    palette[0] = accent;
+    return Xml.declaration() + '<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="DarkSlide"><a:themeElements><a:clrScheme name="DarkSlide"><a:dk1><a:srgbClr val="' + text + '"/></a:dk1><a:lt1><a:srgbClr val="' + bg + '"/></a:lt1><a:dk2><a:srgbClr val="' + muted + '"/></a:dk2><a:lt2><a:srgbClr val="' + surface + '"/></a:lt2><a:accent1><a:srgbClr val="' + palette[0] + '"/></a:accent1><a:accent2><a:srgbClr val="' + palette[1] + '"/></a:accent2><a:accent3><a:srgbClr val="' + palette[2] + '"/></a:accent3><a:accent4><a:srgbClr val="' + palette[3] + '"/></a:accent4><a:accent5><a:srgbClr val="' + palette[4] + '"/></a:accent5><a:accent6><a:srgbClr val="' + palette[5] + '"/></a:accent6><a:hlink><a:srgbClr val="0563C1"/></a:hlink><a:folHlink><a:srgbClr val="954F72"/></a:folHlink></a:clrScheme><a:fontScheme name="DarkSlide"><a:majorFont><a:latin typeface="' + heading + '"/><a:ea typeface=""/><a:cs typeface=""/></a:majorFont><a:minorFont><a:latin typeface="' + body + '"/><a:ea typeface=""/><a:cs typeface=""/></a:minorFont></a:fontScheme><a:fmtScheme name="DarkSlide"><a:fillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:fillStyleLst><a:lnStyleLst><a:ln w="6350"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:ln><a:ln w="12700"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:ln><a:ln w="19050"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:ln></a:lnStyleLst><a:effectStyleLst><a:effectStyle><a:effectLst/></a:effectStyle><a:effectStyle><a:effectLst/></a:effectStyle><a:effectStyle><a:effectLst/></a:effectStyle></a:effectStyleLst><a:bgFillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:bgFillStyleLst></a:fmtScheme></a:themeElements></a:theme>';
+  }
+  buildSlideMaster() {
+    return Xml.declaration() + '<p:sldMaster 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"><p:cSld><p:bg><p:bgRef idx="1001"><a:schemeClr val="bg1"/></p:bgRef></p:bg><p:spTree><p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/><a:chOff x="0" y="0"/><a:chExt cx="0" cy="0"/></a:xfrm></p:grpSpPr></p:spTree></p:cSld><p:clrMap bg1="lt1" tx1="dk1" bg2="lt2" tx2="dk2" accent1="accent1" accent2="accent2" accent3="accent3" accent4="accent4" accent5="accent5" accent6="accent6" hlink="hlink" folHlink="folHlink"/><p:sldLayoutIdLst>' + this.buildSlideLayoutIdLst() + '</p:sldLayoutIdLst><p:txStyles><p:titleStyle><a:lvl1pPr algn="ctr"><a:defRPr sz="4400"><a:solidFill><a:schemeClr val="tx1"/></a:solidFill></a:defRPr></a:lvl1pPr></p:titleStyle><p:bodyStyle><a:lvl1pPr><a:defRPr sz="2400"><a:solidFill><a:schemeClr val="tx1"/></a:solidFill></a:defRPr></a:lvl1pPr></p:bodyStyle><p:otherStyle/></p:txStyles></p:sldMaster>';
+  }
+  buildSlideLayoutIdLst() {
+    let out = "";
+    LAYOUT_ORDER.forEach((_, idx) => {
+      const n = idx + 1;
+      const id = 2147483648 + n;
+      out += '<p:sldLayoutId id="' + id + '" r:id="rId' + n + '"/>';
+    });
+    return out;
+  }
+  buildSlideMasterRels() {
+    let rels = "";
+    LAYOUT_ORDER.forEach((_, idx) => {
+      const n = idx + 1;
+      rels += '<Relationship Id="rId' + n + '" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout" Target="../slideLayouts/slideLayout' + n + '.xml"/>';
+    });
+    const themeRid = "rId" + (LAYOUT_ORDER.length + 1);
+    rels += '<Relationship Id="' + themeRid + '" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" Target="../theme/theme1.xml"/>';
+    return Xml.declaration() + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">' + rels + "</Relationships>";
+  }
+  layoutNumberFor(layout) {
+    if (layout === null || layout === void 0) {
+      return 1;
+    }
+    const idx = LAYOUT_ORDER.indexOf(layout);
+    return idx === -1 ? 1 : idx + 1;
+  }
+  layoutTypeFor(layout) {
+    switch (layout) {
+      case "title":
+        return "title";
+      case "title-content":
+        return "obj";
+      case "two-column":
+        return "twoObj";
+      case "section-divider":
+        return "secHead";
+      case "image-text":
+      case "text-image":
+        return "picTx";
+      case "quote":
+        return "obj";
+      default:
+        return "blank";
+    }
+  }
+  buildSlideLayout(layout) {
+    const type = this.layoutTypeFor(layout);
+    const name = Xml.attr(ucwords(layout.replace(/-/g, " ")));
+    return Xml.declaration() + '<p:sldLayout 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" type="' + type + '" preserve="1"><p:cSld name="' + name + '"><p:spTree><p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/><a:chOff x="0" y="0"/><a:chExt cx="0" cy="0"/></a:xfrm></p:grpSpPr></p:spTree></p:cSld><p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr></p:sldLayout>';
+  }
+  buildSlideLayoutRels() {
+    return Xml.declaration() + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster" Target="../slideMasters/slideMaster1.xml"/></Relationships>';
+  }
+  // ─── Per-slide rendering ──────────────────────────────────────────────
+  buildSlideXml(slide, slideNumber, deck = {}) {
+    const elements = [...slide?.elements ?? []];
+    elements.sort((a, b) => (a?.z ?? -1) - (b?.z ?? -1));
+    let shapeId = 2;
+    let shapeTreeXml = "";
+    let slideRels = [];
+    const bgResult = this.buildBackground(slide?.background ?? null, slideNumber, slideRels);
+    const bg = bgResult.xml;
+    slideRels = bgResult.rels;
+    const animatedBuilds = [];
+    elements.forEach((element, arrayIndex) => {
+      if (!isPlainObject(element) || element.type === void 0) {
+        return;
+      }
+      if (element.hidden) {
+        return;
+      }
+      const [xml, rels] = this.buildElementXml(element, shapeId, slideNumber);
+      if (xml === "") {
+        return;
+      }
+      shapeTreeXml += xml;
+      slideRels = slideRels.concat(rels);
+      if (isPlainObject(element.animation) && element.animation.effect !== void 0) {
+        let paragraphCount = null;
+        if (element.type === "text" && element.animation.byParagraph) {
+          paragraphCount = String(element.content ?? "").split("\n").length;
+        }
+        animatedBuilds.push({
+          shapeId,
+          arrayIndex,
+          animation: element.animation,
+          paragraphCount
+        });
+      }
+      shapeId++;
+    });
+    this.pendingSlideRels[slideNumber] = slideRels;
+    const transition = this.buildTransition(slide?.transition ?? null, deck?.theme?.defaultTransition ?? null);
+    const timing = this.buildTiming(animatedBuilds);
+    return Xml.declaration() + '<p:sld 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"><p:cSld>' + bg + '<p:spTree><p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/><a:chOff x="0" y="0"/><a:chExt cx="0" cy="0"/></a:xfrm></p:grpSpPr>' + shapeTreeXml + "</p:spTree></p:cSld>" + transition + timing + "</p:sld>";
+  }
+  buildTransition(transition, fallback) {
+    let spec = isPlainObject(transition) ? transition : null;
+    if (spec === null || (spec.kind ?? null) === null || (spec.kind ?? null) === "none") {
+      spec = isPlainObject(fallback) ? fallback : null;
+    }
+    if (spec === null) {
+      return "";
+    }
+    const kind = typeof spec.kind === "string" ? String(spec.kind).toLowerCase() : "none";
+    if (kind === "none" || !Schema.SLIDE_TRANSITION_KINDS.includes(kind)) {
+      return "";
+    }
+    const spd = this.transitionSpeed(spec.duration ?? null);
+    let effect;
+    switch (kind) {
+      case "fade":
+        effect = "<p:fade/>";
+        break;
+      case "slide":
+        effect = '<p:push dir="' + this.transitionDirection(spec.direction ?? null) + '"/>';
+        break;
+      case "zoom":
+        effect = "<p:circle/>";
+        break;
+      default:
+        effect = "";
+    }
+    if (effect === "") {
+      return "";
+    }
+    return '<p:transition spd="' + spd + '">' + effect + "</p:transition>";
+  }
+  transitionSpeed(duration) {
+    if (!isNumeric(duration)) {
+      return "med";
+    }
+    const ms = parseFloat(String(duration));
+    if (ms >= 700) {
+      return "slow";
+    }
+    if (ms <= 250) {
+      return "fast";
+    }
+    return "med";
+  }
+  transitionDirection(direction) {
+    switch (typeof direction === "string" ? direction.toLowerCase() : "") {
+      case "left":
+        return "l";
+      case "right":
+        return "r";
+      case "up":
+        return "u";
+      case "down":
+        return "d";
+      default:
+        return "l";
+    }
+  }
+  // ─── Element entrance animations (`<p:timing>`) ───────────────────────────
+  buildTiming(builds) {
+    if (builds.length === 0) {
+      return "";
+    }
+    const sorted = [...builds];
+    sorted.sort((a, b) => {
+      const ao = isNumeric(a.animation.order) ? parseFloat(String(a.animation.order)) : 0;
+      const bo = isNumeric(b.animation.order) ? parseFloat(String(b.animation.order)) : 0;
+      if (ao !== bo) {
+        return ao < bo ? -1 : 1;
+      }
+      return a.arrayIndex - b.arrayIndex;
+    });
+    const subBuilds = [];
+    for (const build of sorted) {
+      const paragraphCount = build.paragraphCount ?? null;
+      if (paragraphCount === null || paragraphCount <= 1) {
+        subBuilds.push({
+          shapeId: build.shapeId,
+          arrayIndex: build.arrayIndex,
+          animation: build.animation,
+          paragraph: paragraphCount === null ? null : 0
+        });
+        continue;
+      }
+      for (let i = 0; i < paragraphCount; i++) {
+        const animation = { ...build.animation };
+        if (i > 0) {
+          animation.trigger = "on-click";
+        }
+        subBuilds.push({
+          shapeId: build.shapeId,
+          arrayIndex: build.arrayIndex,
+          animation,
+          paragraph: i
+        });
+      }
+    }
+    const steps = [];
+    for (const build of subBuilds) {
+      const trigger = this.animationTrigger(build.animation.trigger ?? null);
+      if (steps.length === 0 || trigger === "on-click") {
+        steps.push([build]);
+      } else {
+        steps[steps.length - 1].push(build);
+      }
+    }
+    this.tnId = 1;
+    const rootId = this.tnId++;
+    let stepPars = "";
+    for (const step of steps) {
+      stepPars += this.buildStepPar(step);
+    }
+    const mainSeqId = this.tnId++;
+    return '<p:timing><p:tnLst><p:par><p:cTn id="' + rootId + '" dur="indefinite" restart="never" nodeType="tmRoot"><p:childTnLst><p:seq concurrent="1" nextAc="seek"><p:cTn id="' + mainSeqId + '" dur="indefinite" nodeType="mainSeq"><p:childTnLst>' + stepPars + '</p:childTnLst></p:cTn><p:prevCondLst><p:cond evt="onPrev" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:prevCondLst><p:nextCondLst><p:cond evt="onNext" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:nextCondLst></p:seq></p:childTnLst></p:cTn></p:par></p:tnLst></p:timing>';
+  }
+  buildTargetEl(spid, paragraph) {
+    if (paragraph === null) {
+      return '<p:tgtEl><p:spTgt spid="' + spid + '"/></p:tgtEl>';
+    }
+    return '<p:tgtEl><p:spTgt spid="' + spid + '"><p:txEl><p:pRg st="' + paragraph + '" end="' + paragraph + '"/></p:txEl></p:spTgt></p:tgtEl>';
+  }
+  buildStepPar(step) {
+    const lead = step[0];
+    const leadDelay = this.animationDelay(lead.animation);
+    const leadDuration = this.animationDuration(lead.animation);
+    let childTns = "";
+    step.forEach((build, i) => {
+      let begin;
+      if (i === 0) {
+        begin = leadDelay;
+      } else {
+        const trigger = this.animationTrigger(build.animation.trigger ?? null);
+        const base = trigger === "after-prev" ? leadDelay + leadDuration : leadDelay;
+        begin = base + this.animationDelay(build.animation);
+      }
+      childTns += this.buildEffectPar(build, begin);
+    });
+    const stepId = this.tnId++;
+    return '<p:par><p:cTn id="' + stepId + '" fill="hold"><p:stCondLst><p:cond delay="indefinite"/></p:stCondLst><p:childTnLst>' + childTns + "</p:childTnLst></p:cTn></p:par>";
+  }
+  buildEffectPar(build, beginMs) {
+    const spid = build.shapeId;
+    const paragraph = build.paragraph;
+    const animation = build.animation;
+    const effect = this.animationEffect(animation.effect ?? null);
+    const duration = this.animationDuration(animation);
+    const direction = this.animationDirection(animation.direction ?? null);
+    const wrapId = this.tnId++;
+    const stCond = '<p:stCondLst><p:cond delay="' + Math.max(0, beginMs) + '"/></p:stCondLst>';
+    let effectXml;
+    switch (effect) {
+      case "fly-in":
+        effectXml = this.buildFlyInEffect(spid, duration, direction, paragraph);
+        break;
+      case "zoom":
+        effectXml = this.buildZoomEffect(spid, duration, paragraph);
+        break;
+      case "wipe":
+        effectXml = this.buildWipeEffect(spid, duration, direction, paragraph);
+        break;
+      default:
+        effectXml = this.buildFadeEffect(spid, duration, paragraph);
+    }
+    const presetId = this.animationPresetId(effect);
+    return '<p:par><p:cTn id="' + wrapId + '" presetID="' + presetId + '" presetClass="entr" presetSubtype="0" fill="hold">' + stCond + "<p:childTnLst>" + effectXml + "</p:childTnLst></p:cTn></p:par>";
+  }
+  animationPresetId(effect) {
+    switch (effect) {
+      case "fly-in":
+        return 2;
+      case "wipe":
+        return 22;
+      case "zoom":
+        return 23;
+      default:
+        return 10;
+    }
+  }
+  buildVisibilitySet(spid, paragraph = null) {
+    const id = this.tnId++;
+    return '<p:set><p:cBhvr><p:cTn id="' + id + '" dur="1" fill="hold"><p:stCondLst><p:cond delay="0"/></p:stCondLst></p:cTn>' + this.buildTargetEl(spid, paragraph) + '<p:attrNameLst><p:attrName>style.visibility</p:attrName></p:attrNameLst></p:cBhvr><p:to><p:strVal val="visible"/></p:to></p:set>';
+  }
+  buildFadeEffect(spid, durationMs, paragraph = null) {
+    const set = this.buildVisibilitySet(spid, paragraph);
+    const id = this.tnId++;
+    const effect = '<p:animEffect transition="in" filter="fade"><p:cBhvr><p:cTn id="' + id + '" dur="' + durationMs + '"/>' + this.buildTargetEl(spid, paragraph) + "</p:cBhvr></p:animEffect>";
+    return set + effect;
+  }
+  buildFlyInEffect(spid, durationMs, direction, paragraph = null) {
+    const set = this.buildVisibilitySet(spid, paragraph);
+    let attr, fromExpr, toExpr;
+    switch (direction) {
+      case "right":
+        [attr, fromExpr, toExpr] = ["ppt_x", "1+#ppt_w/2", "#ppt_x"];
+        break;
+      case "up":
+        [attr, fromExpr, toExpr] = ["ppt_y", "0-#ppt_h/2", "#ppt_y"];
+        break;
+      case "down":
+        [attr, fromExpr, toExpr] = ["ppt_y", "1+#ppt_h/2", "#ppt_y"];
+        break;
+      default:
+        [attr, fromExpr, toExpr] = ["ppt_x", "0-#ppt_w/2", "#ppt_x"];
+    }
+    const id = this.tnId++;
+    const anim = '<p:anim calcmode="lin" valueType="num"><p:cBhvr additive="base"><p:cTn id="' + id + '" dur="' + durationMs + '" fill="hold"/>' + this.buildTargetEl(spid, paragraph) + "<p:attrNameLst><p:attrName>" + attr + '</p:attrName></p:attrNameLst></p:cBhvr><p:tavLst><p:tav tm="0"><p:val><p:strVal val="' + fromExpr + '"/></p:val></p:tav><p:tav tm="100000"><p:val><p:strVal val="' + toExpr + '"/></p:val></p:tav></p:tavLst></p:anim>';
+    return set + anim;
+  }
+  buildZoomEffect(spid, durationMs, paragraph = null) {
+    const set = this.buildVisibilitySet(spid, paragraph);
+    const fadeId = this.tnId++;
+    const scaleId = this.tnId++;
+    const fade = '<p:animEffect transition="in" filter="fade"><p:cBhvr><p:cTn id="' + fadeId + '" dur="' + durationMs + '"/>' + this.buildTargetEl(spid, paragraph) + "</p:cBhvr></p:animEffect>";
+    const scale = '<p:animScale><p:cBhvr><p:cTn id="' + scaleId + '" dur="' + durationMs + '" fill="hold"/>' + this.buildTargetEl(spid, paragraph) + '</p:cBhvr><p:from x="0" y="0"/><p:to x="100000" y="100000"/></p:animScale>';
+    return set + fade + scale;
+  }
+  buildWipeEffect(spid, durationMs, direction, paragraph = null) {
+    const set = this.buildVisibilitySet(spid, paragraph);
+    let filter;
+    switch (direction) {
+      case "right":
+        filter = "wipe(left)";
+        break;
+      case "up":
+        filter = "wipe(down)";
+        break;
+      case "down":
+        filter = "wipe(up)";
+        break;
+      default:
+        filter = "wipe(right)";
+    }
+    const id = this.tnId++;
+    const effect = '<p:animEffect transition="in" filter="' + filter + '"><p:cBhvr><p:cTn id="' + id + '" dur="' + durationMs + '"/>' + this.buildTargetEl(spid, paragraph) + "</p:cBhvr></p:animEffect>";
+    return set + effect;
+  }
+  animationEffect(effect) {
+    const name = typeof effect === "string" ? effect.toLowerCase() : "";
+    return Schema.ANIMATION_EFFECTS.includes(name) ? name : "fade";
+  }
+  animationTrigger(trigger) {
+    const name = typeof trigger === "string" ? trigger.toLowerCase() : "";
+    return Schema.ANIMATION_TRIGGERS.includes(name) ? name : "on-click";
+  }
+  animationDirection(direction) {
+    const name = typeof direction === "string" ? direction.toLowerCase() : "";
+    return Schema.ANIMATION_DIRECTIONS.includes(name) ? name : "left";
+  }
+  animationDuration(animation) {
+    const duration = isNumeric(animation.duration) ? Math.round(parseFloat(String(animation.duration))) : Schema.ANIMATION_DEFAULT_DURATION_MS;
+    return Math.max(1, duration);
+  }
+  animationDelay(animation) {
+    const delay = isNumeric(animation.delay) ? Math.round(parseFloat(String(animation.delay))) : 0;
+    return Math.max(0, delay);
+  }
+  // ─── Background ───────────────────────────────────────────────────────
+  buildBackground(bg, slideNumber, rels) {
+    if (!isPlainObject(bg)) {
+      return { xml: "", rels };
+    }
+    if (typeof bg.image === "string" && bg.image !== "") {
+      const embed = this.stageMedia(bg.image, slideNumber);
+      if (embed !== null) {
+        rels.push({
+          id: embed.relId,
+          type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+          target: embed.target
+        });
+        return {
+          xml: '<p:bg><p:bgPr><a:blipFill dpi="0" rotWithShape="1"><a:blip r:embed="' + embed.relId + '"/><a:srcRect/><a:stretch><a:fillRect/></a:stretch></a:blipFill><a:effectLst/></p:bgPr></p:bg>',
+          rels
+        };
+      }
+    }
+    if (typeof bg.gradient === "string") {
+      const grad = this.parseGradient(bg.gradient);
+      if (grad !== null) {
+        return { xml: "<p:bg><p:bgPr>" + grad + "<a:effectLst/></p:bgPr></p:bg>", rels };
+      }
+    }
+    if (typeof bg.color === "string") {
+      const [hex, alpha] = Color.parse(bg.color);
+      return {
+        xml: '<p:bg><p:bgPr><a:solidFill><a:srgbClr val="' + hex + '"><a:alpha val="' + alpha + '"/></a:srgbClr></a:solidFill><a:effectLst/></p:bgPr></p:bg>',
+        rels
+      };
+    }
+    return { xml: "", rels };
+  }
+  parseGradient(cssInput) {
+    const css = cssInput.trim();
+    const m = /^linear-gradient\((.+)\)\s*;?\s*$/i.exec(css);
+    if (!m) {
+      return null;
+    }
+    const args = m[1];
+    const parts = this.splitTopLevelCommas(args);
+    if (parts.length < 2) {
+      return null;
+    }
+    let angleDeg = 90;
+    const first = parts[0].trim();
+    const directionLike = /^(?:to\s+|[-+]?[0-9.]+(?:deg|rad|turn|grad)?\s*$)/i.test(first);
+    if (directionLike) {
+      angleDeg = this.parseGradientDirection(first);
+      parts.shift();
+    }
+    const stops = [];
+    const count = parts.length;
+    parts.forEach((partRaw, i) => {
+      const part = partRaw.trim();
+      let colorStr;
+      let pos;
+      const sm = /^(.+?)\s+([0-9.]+%?)\s*$/.exec(part);
+      if (sm) {
+        colorStr = sm[1];
+        const posStr = sm[2];
+        if (posStr.endsWith("%")) {
+          pos = parseFloat(posStr.replace(/%+$/, "")) / 100;
+        } else {
+          pos = parseFloat(posStr);
+        }
+      } else {
+        colorStr = part;
+        pos = count <= 1 ? 0 : i / (count - 1);
+      }
+      const [hex] = Color.parse(colorStr);
+      stops.push({ hex, pos: Math.max(0, Math.min(1, pos)) });
+    });
+    let gsList = "";
+    for (const stop of stops) {
+      const pos1000 = Math.round(stop.pos * 1e5);
+      gsList += '<a:gs pos="' + pos1000 + '"><a:srgbClr val="' + stop.hex + '"/></a:gs>';
+    }
+    let pptxAngle = Math.round((angleDeg - 90) * 6e4);
+    pptxAngle = (pptxAngle % (360 * 6e4) + 360 * 6e4) % (360 * 6e4);
+    return '<a:gradFill flip="none" rotWithShape="1"><a:gsLst>' + gsList + '</a:gsLst><a:lin ang="' + pptxAngle + '" scaled="0"/></a:gradFill>';
+  }
+  splitTopLevelCommas(s) {
+    const out = [];
+    let depth = 0;
+    let buf = "";
+    for (let i = 0; i < s.length; i++) {
+      const c = s[i];
+      if (c === "(") {
+        depth++;
+        buf += c;
+      } else if (c === ")") {
+        depth = Math.max(0, depth - 1);
+        buf += c;
+      } else if (c === "," && depth === 0) {
+        out.push(buf);
+        buf = "";
+      } else {
+        buf += c;
+      }
+    }
+    if (buf !== "") {
+      out.push(buf);
+    }
+    return out;
+  }
+  parseGradientDirection(dirInput) {
+    const dir = dirInput.trim();
+    let m = /^([-+]?[0-9.]+)deg$/i.exec(dir);
+    if (m) {
+      return parseFloat(m[1]);
+    }
+    m = /^([-+]?[0-9.]+)rad$/i.exec(dir);
+    if (m) {
+      return parseFloat(m[1]) * 180 / Math.PI;
+    }
+    m = /^([-+]?[0-9.]+)turn$/i.exec(dir);
+    if (m) {
+      return parseFloat(m[1]) * 360;
+    }
+    switch (dir.toLowerCase()) {
+      case "to top":
+        return 0;
+      case "to top right":
+        return 45;
+      case "to right":
+        return 90;
+      case "to bottom right":
+        return 135;
+      case "to bottom":
+        return 180;
+      case "to bottom left":
+        return 225;
+      case "to left":
+        return 270;
+      case "to top left":
+        return 315;
+      default:
+        return 180;
+    }
+  }
+  // ─── Element dispatch ─────────────────────────────────────────────────
+  buildElementXml(element, shapeId, slideNumber) {
+    const rels = [];
+    let xml;
+    switch (element.type) {
+      case "text":
+        xml = this.buildTextShape(element, shapeId);
+        break;
+      case "image":
+        xml = this.buildImageShape(element, shapeId, slideNumber, rels);
+        break;
+      case "shape":
+        xml = this.buildShape(element, shapeId);
+        break;
+      case "code":
+        xml = this.buildCodeShape(element, shapeId);
+        break;
+      case "chart":
+        xml = this.buildChart(element, shapeId, slideNumber, rels);
+        break;
+      case "table":
+        xml = this.buildTable(element, shapeId);
+        break;
+      case "embed":
+        xml = this.buildPlaceholder("[embed: " + String(element.src ?? "") + "]", element, shapeId);
+        break;
+      default:
+        xml = "";
+    }
+    xml = this.applyHyperlink(xml, element, shapeId, rels);
+    return [xml, rels];
+  }
+  applyHyperlink(xml, element, shapeId, rels) {
+    const href = element.href ?? null;
+    if (typeof href !== "string" || href === "" || xml === "") {
+      return xml;
+    }
+    const relId = "rIdLink" + shapeId;
+    rels.push({
+      id: relId,
+      type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+      target: href,
+      mode: "External"
+    });
+    const hlink = '<a:hlinkClick r:id="' + relId + '"/>';
+    let count = 0;
+    const injected = xml.replace(/<p:cNvPr\b([^>]*)\/>/, (_full, attrs) => {
+      if (count > 0) return _full;
+      count++;
+      return "<p:cNvPr" + attrs + ">" + hlink + "</p:cNvPr>";
+    });
+    return count > 0 ? injected : xml;
+  }
+  // ─── Element renderers ────────────────────────────────────────────────
+  buildTextShape(element, shapeId) {
+    const xfrm = this.xfrmFromFractions(element);
+    const body = this.buildTextBody(
+      String(element.content ?? ""),
+      element.style ?? {},
+      String(element.format ?? "plain")
+    );
+    const id = element.id ?? `text-${shapeId}`;
+    return '<p:sp><p:nvSpPr><p:cNvPr id="' + shapeId + '" name="' + Xml.attr(String(id)) + '"/><p:cNvSpPr txBox="1"/><p:nvPr/></p:nvSpPr><p:spPr>' + xfrm + '<a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:noFill/></p:spPr>' + body + "</p:sp>";
+  }
+  buildImageShape(element, shapeId, slideNumber, rels) {
+    const src = String(element.src ?? "");
+    const embed = this.stageMedia(src, slideNumber);
+    if (embed === null) {
+      return this.buildPlaceholder("[image: " + src + "]", element, shapeId);
+    }
+    const relId = embed.relId;
+    rels.push({
+      id: relId,
+      type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+      target: embed.target
+    });
+    const id = element.id ?? `image-${shapeId}`;
+    const alt = Xml.attr(String(element.alt ?? ""));
+    const fit = typeof element.fit === "string" ? element.fit.toLowerCase() : "fill";
+    const boxX = Emu.fromFracX(toFloat(element.x ?? 0));
+    const boxY = Emu.fromFracY(toFloat(element.y ?? 0));
+    const boxW = Math.max(1, Emu.fromFracX(toFloat(element.w ?? 0)));
+    const boxH = Math.max(1, Emu.fromFracY(toFloat(element.h ?? 0)));
+    const intrinsic = getImageSize(embed.bytes);
+    const imgW = intrinsic ? intrinsic[0] : 0;
+    const imgH = intrinsic ? intrinsic[1] : 0;
+    let offX = boxX;
+    let offY = boxY;
+    let extW = boxW;
+    let extH = boxH;
+    let srcRect = "";
+    const explicitCrop = this.imageCropRect(element.crop ?? null);
+    if (explicitCrop !== null) {
+      srcRect = explicitCrop;
+    } else if (fit === "cover" && imgW > 0 && imgH > 0) {
+      srcRect = this.coverSrcRect(boxW, boxH, imgW, imgH);
+    } else if ((fit === "contain" || fit === "scale-down") && imgW > 0 && imgH > 0) {
+      [offX, offY, extW, extH] = this.containedRect(boxX, boxY, boxW, boxH, imgW, imgH);
+    }
+    const blipFill = '<p:blipFill><a:blip r:embed="' + relId + '"/>' + srcRect + "<a:stretch><a:fillRect/></a:stretch></p:blipFill>";
+    return '<p:pic><p:nvPicPr><p:cNvPr id="' + shapeId + '" name="' + Xml.attr(String(id)) + '" descr="' + alt + '"/><p:cNvPicPr><a:picLocks noChangeAspect="1"/></p:cNvPicPr><p:nvPr/></p:nvPicPr>' + blipFill + '<p:spPr><a:xfrm><a:off x="' + offX + '" y="' + offY + '"/><a:ext cx="' + extW + '" cy="' + extH + '"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr></p:pic>';
+  }
+  imageCropRect(crop) {
+    if (!isPlainObject(crop)) {
+      return null;
+    }
+    const x = isNumeric(crop.x) ? parseFloat(String(crop.x)) : null;
+    const y = isNumeric(crop.y) ? parseFloat(String(crop.y)) : null;
+    const w = isNumeric(crop.w) ? parseFloat(String(crop.w)) : null;
+    const h = isNumeric(crop.h) ? parseFloat(String(crop.h)) : null;
+    if (x === null || y === null || w === null || h === null) {
+      return null;
+    }
+    let l = Math.round(x * 1e5);
+    let t = Math.round(y * 1e5);
+    let r = Math.round((1 - x - w) * 1e5);
+    let b = Math.round((1 - y - h) * 1e5);
+    l = Math.max(0, Math.min(1e5, l));
+    t = Math.max(0, Math.min(1e5, t));
+    r = Math.max(0, Math.min(1e5, r));
+    b = Math.max(0, Math.min(1e5, b));
+    return '<a:srcRect l="' + l + '" t="' + t + '" r="' + r + '" b="' + b + '"/>';
+  }
+  coverSrcRect(boxW, boxH, imgW, imgH) {
+    const boxAspect = boxW / boxH;
+    const imgAspect = imgW / imgH;
+    let l = 0, t = 0, r = 0, b = 0;
+    if (imgAspect > boxAspect) {
+      const visibleFrac = boxAspect / imgAspect;
+      const inset = Math.round((1 - visibleFrac) / 2 * 1e5);
+      l = inset;
+      r = inset;
+    } else if (imgAspect < boxAspect) {
+      const visibleFrac = imgAspect / boxAspect;
+      const inset = Math.round((1 - visibleFrac) / 2 * 1e5);
+      t = inset;
+      b = inset;
+    }
+    return '<a:srcRect l="' + l + '" t="' + t + '" r="' + r + '" b="' + b + '"/>';
+  }
+  containedRect(boxX, boxY, boxW, boxH, imgW, imgH) {
+    const scale = Math.min(boxW / imgW, boxH / imgH);
+    const extW = Math.max(1, Math.round(imgW * scale));
+    const extH = Math.max(1, Math.round(imgH * scale));
+    const offX = boxX + Math.round((boxW - extW) / 2);
+    const offY = boxY + Math.round((boxH - extH) / 2);
+    return [offX, offY, extW, extH];
+  }
+  buildShape(element, shapeId) {
+    const xfrm = this.xfrmFromFractions(element);
+    const id = element.id ?? `shape-${shapeId}`;
+    const kind = String(element.shape ?? "rect");
+    let prst;
+    switch (kind) {
+      case "rect":
+        prst = "rect";
+        break;
+      case "rounded-rect":
+        prst = "roundRect";
+        break;
+      case "ellipse":
+        prst = "ellipse";
+        break;
+      case "triangle":
+        prst = "triangle";
+        break;
+      case "line":
+        prst = "line";
+        break;
+      case "arrow":
+        prst = "rightArrow";
+        break;
+      default:
+        prst = "rect";
+    }
+    const [fillHex, fillAlpha] = Color.parse(element.fill ?? "rgba(139,92,246,0.15)", "8B5CF6");
+    const [strokeHex] = Color.parse(element.stroke ?? "#8B5CF6", "8B5CF6");
+    const strokeWidthEmu = Emu.fromPt(toFloat(element.strokeWidth ?? 2));
+    const dashStr = element.dashed ? '<a:prstDash val="dash"/>' : "";
+    const fillXml = fillAlpha === 0 ? "<a:noFill/>" : '<a:solidFill><a:srgbClr val="' + fillHex + '"><a:alpha val="' + fillAlpha + '"/></a:srgbClr></a:solidFill>';
+    return '<p:sp><p:nvSpPr><p:cNvPr id="' + shapeId + '" name="' + Xml.attr(String(id)) + '"/><p:cNvSpPr/><p:nvPr/></p:nvSpPr><p:spPr>' + xfrm + '<a:prstGeom prst="' + prst + '"><a:avLst/></a:prstGeom>' + fillXml + '<a:ln w="' + strokeWidthEmu + '"><a:solidFill><a:srgbClr val="' + strokeHex + '"/></a:solidFill>' + dashStr + '</a:ln></p:spPr><p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:endParaRPr lang="en-US"/></a:p></p:txBody></p:sp>';
+  }
+  buildCodeShape(element, shapeId) {
+    const xfrm = this.xfrmFromFractions(element);
+    const code = String(element.code ?? "");
+    const id = element.id ?? `code-${shapeId}`;
+    const language = element.language !== void 0 && element.language !== null ? String(element.language) : null;
+    const body = this.buildHighlightedCodeBody(code, language);
+    return '<p:sp><p:nvSpPr><p:cNvPr id="' + shapeId + '" name="' + Xml.attr(String(id)) + '"/><p:cNvSpPr txBox="1"/><p:nvPr/></p:nvSpPr><p:spPr>' + xfrm + '<a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:solidFill><a:srgbClr val="0F172A"/></a:solidFill></p:spPr>' + body + "</p:sp>";
+  }
+  buildHighlightedCodeBody(code, language) {
+    const sz = Emu.hundredthsOfPoint(12);
+    let paragraphs = "";
+    const lines = code.split("\n");
+    for (const line of lines) {
+      const tokens = SyntaxHighlighter.tokenize(line, language);
+      let runs = "";
+      for (const token of tokens) {
+        if (token.text === "") {
+          continue;
+        }
+        const color = SyntaxHighlighter.colorFor(token.kind);
+        runs += '<a:r><a:rPr lang="en-US" sz="' + sz + '"><a:solidFill><a:srgbClr val="' + color + '"/></a:solidFill><a:latin typeface="Consolas"/></a:rPr><a:t>' + Xml.text(token.text) + "</a:t></a:r>";
+      }
+      if (runs === "") {
+        runs = '<a:endParaRPr lang="en-US" sz="' + sz + '"/>';
+      }
+      paragraphs += '<a:p><a:pPr algn="l"/>' + runs + "</a:p>";
+    }
+    return '<p:txBody><a:bodyPr wrap="square" anchor="t" rtlCol="0" lIns="91440" tIns="45720" rIns="91440" bIns="45720"/><a:lstStyle/>' + paragraphs + "</p:txBody>";
+  }
+  buildTable(element, shapeId) {
+    const columns = Array.isArray(element.columns) ? element.columns : [];
+    const rows = Array.isArray(element.rows) ? element.rows : [];
+    if (columns.length === 0) {
+      return this.buildPlaceholder("[table: no columns]", element, shapeId);
+    }
+    const totalWidthEmu = Emu.fromFracX(toFloat(element.w ?? 0.5));
+    const colCount = columns.length;
+    const colWidthEmu = Math.round(totalWidthEmu / Math.max(1, colCount));
+    const headerRowH = Emu.fromPt(40);
+    const bodyRowH = Emu.fromPt(30);
+    let gridCols = "";
+    for (let i = 0; i < columns.length; i++) {
+      gridCols += '<a:gridCol w="' + colWidthEmu + '"/>';
+    }
+    let headerCells = "";
+    for (const col of columns) {
+      const label = String(col.label ?? col.key ?? "");
+      headerCells += this.buildTableCell(label, true);
+    }
+    const headerRow = '<a:tr h="' + headerRowH + '">' + headerCells + "</a:tr>";
+    let bodyRows = "";
+    let rowIndex = 0;
+    for (const row of rows) {
+      if (!isPlainObject(row)) {
+        continue;
+      }
+      let cells = "";
+      for (const col of columns) {
+        const key = String(col.key ?? "");
+        const value = row[key] ?? "";
+        const text = isScalar2(value) ? scalarToString(value) : JSON.stringify(value);
+        cells += this.buildTableCell(String(text), false, rowIndex % 2 === 1);
+      }
+      bodyRows += '<a:tr h="' + bodyRowH + '">' + cells + "</a:tr>";
+      rowIndex++;
+    }
+    const xfrm = this.xfrmFromFractions(element);
+    const id = element.id ?? `table-${shapeId}`;
+    return '<p:graphicFrame><p:nvGraphicFramePr><p:cNvPr id="' + shapeId + '" name="' + Xml.attr(String(id)) + '"/><p:cNvGraphicFramePr><a:graphicFrameLocks noGrp="1"/></p:cNvGraphicFramePr><p:nvPr/></p:nvGraphicFramePr><p:xfrm>' + innerXfrm(xfrm) + '</p:xfrm><a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/table"><a:tbl><a:tblPr firstRow="1" bandRow="1"><a:tableStyleId>{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}</a:tableStyleId></a:tblPr><a:tblGrid>' + gridCols + "</a:tblGrid>" + headerRow + bodyRows + "</a:tbl></a:graphicData></a:graphic></p:graphicFrame>";
+  }
+  buildTableCell(text, header, striped = false) {
+    let fill;
+    let textColor;
+    let bold;
+    if (header) {
+      fill = '<a:solidFill><a:srgbClr val="8B5CF6"/></a:solidFill>';
+      textColor = "FFFFFF";
+      bold = ' b="1"';
+    } else {
+      fill = striped ? '<a:solidFill><a:srgbClr val="F8FAFC"/></a:solidFill>' : "<a:noFill/>";
+      textColor = "0F172A";
+      bold = "";
+    }
+    return '<a:tc><a:txBody><a:bodyPr wrap="square" anchor="ctr" lIns="91440" tIns="45720" rIns="91440" bIns="45720"/><a:lstStyle/><a:p><a:pPr algn="l"/><a:r><a:rPr lang="en-US" sz="1400"' + bold + '><a:solidFill><a:srgbClr val="' + textColor + '"/></a:solidFill></a:rPr><a:t>' + Xml.text(text) + "</a:t></a:r></a:p></a:txBody><a:tcPr>" + fill + "</a:tcPr></a:tc>";
+  }
+  // ─── Charts ───────────────────────────────────────────────────────────
+  buildChart(element, shapeId, slideNumber, rels) {
+    const option = isPlainObject(element.option) ? element.option : null;
+    const spec = option !== null ? ChartTranslator.translate(option) : null;
+    if (spec !== null) {
+      this.chartCounter++;
+      const n = this.chartCounter;
+      const archivePath = `ppt/charts/chart${n}.xml`;
+      this.chartFiles.push({ path: archivePath, xml: this.buildChartPart(spec) });
+      const relId = "rIdChart" + n;
+      rels.push({
+        id: relId,
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart",
+        target: `../charts/chart${n}.xml`
+      });
+      return this.buildChartFrame(element, shapeId, relId);
+    }
+    const preRender = this.chartPreRenderSrc(element);
+    if (preRender !== null) {
+      const imageElement = { ...element };
+      imageElement.src = preRender;
+      imageElement.fit = element.fit ?? "contain";
+      return this.buildImageShape(imageElement, shapeId, slideNumber, rels);
+    }
+    let title = "";
+    if (isPlainObject(option)) {
+      title = String(option.title?.text ?? "");
+    }
+    const label = title !== "" ? title : "chart";
+    return this.buildChartPlaceholder(label, element, shapeId);
+  }
+  chartPreRenderSrc(element) {
+    for (const key of ["image", "src"]) {
+      const value = element[key] ?? null;
+      if (typeof value === "string" && value.startsWith("data:")) {
+        return value;
+      }
+    }
+    return null;
+  }
+  buildChartFrame(element, shapeId, relId) {
+    const xfrm = this.xfrmFromFractions(element);
+    const innerX = innerXfrm(xfrm);
+    const id = element.id ?? `chart-${shapeId}`;
+    return '<p:graphicFrame><p:nvGraphicFramePr><p:cNvPr id="' + shapeId + '" name="' + Xml.attr(String(id)) + '"/><p:cNvGraphicFramePr/><p:nvPr/></p:nvGraphicFramePr><p:xfrm>' + innerX + '</p:xfrm><a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><a:graphicData uri="' + NS_CHART + '"><c:chart xmlns:c="' + NS_CHART + '" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" r:id="' + relId + '"/></a:graphicData></a:graphic></p:graphicFrame>';
+  }
+  buildChartPart(spec) {
+    const kind = spec.kind;
+    let plot;
+    switch (kind) {
+      case "bar":
+        plot = this.buildBarChartXml(spec);
+        break;
+      case "line":
+        plot = this.buildLineChartXml(spec);
+        break;
+      case "pie":
+        plot = this.buildPieChartXml(spec);
+        break;
+      case "scatter":
+        plot = this.buildScatterChartXml(spec);
+        break;
+      default:
+        plot = this.buildBarChartXml(spec);
+    }
+    let title;
+    if (spec.title !== "") {
+      title = "<c:title><c:tx><c:rich><a:bodyPr/><a:p><a:r><a:t>" + Xml.text(spec.title) + '</a:t></a:r></a:p></c:rich></c:tx><c:overlay val="0"/></c:title><c:autoTitleDeleted val="0"/>';
+    } else {
+      title = '<c:autoTitleDeleted val="1"/>';
+    }
+    return Xml.declaration() + '<c:chartSpace xmlns:c="' + NS_CHART + '" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><c:chart>' + title + "<c:plotArea><c:layout/>" + plot + '</c:plotArea><c:legend><c:legendPos val="b"/><c:overlay val="0"/></c:legend><c:plotVisOnly val="1"/><c:dispBlanksAs val="gap"/></c:chart></c:chartSpace>';
+  }
+  buildBarChartXml(spec) {
+    let sers = "";
+    spec.series.forEach((series, idx) => {
+      sers += '<c:ser><c:idx val="' + idx + '"/><c:order val="' + idx + '"/>' + this.chartSeriesName(series, idx) + this.chartSeriesFill(idx) + this.chartCatRef(spec.categories, series.values) + this.chartValRef(series.values) + "</c:ser>";
+    });
+    return '<c:barChart><c:barDir val="col"/><c:grouping val="clustered"/><c:varyColors val="0"/>' + sers + '<c:axId val="111111111"/><c:axId val="222222222"/></c:barChart>' + this.buildCatValAxes();
+  }
+  buildLineChartXml(spec) {
+    let isArea = false;
+    for (const series of spec.series) {
+      if (series.area) {
+        isArea = true;
+        break;
+      }
+    }
+    let sers = "";
+    spec.series.forEach((series, idx) => {
+      const smooth = !isArea && series.smooth ? '<c:smooth val="1"/>' : "";
+      sers += '<c:ser><c:idx val="' + idx + '"/><c:order val="' + idx + '"/>' + this.chartSeriesName(series, idx) + this.chartSeriesLine(idx) + this.chartCatRef(spec.categories, series.values) + this.chartValRef(series.values) + smooth + "</c:ser>";
+    });
+    if (isArea) {
+      return '<c:areaChart><c:grouping val="standard"/><c:varyColors val="0"/>' + sers + '<c:axId val="111111111"/><c:axId val="222222222"/></c:areaChart>' + this.buildCatValAxes();
+    }
+    return '<c:lineChart><c:grouping val="standard"/><c:varyColors val="0"/>' + sers + '<c:marker val="1"/><c:axId val="111111111"/><c:axId val="222222222"/></c:lineChart>' + this.buildCatValAxes();
+  }
+  buildPieChartXml(spec) {
+    const series = spec.series[0] ?? { values: [], name: "" };
+    const values = Array.isArray(series.values) ? series.values : [];
+    const categories = spec.categories;
+    let dPts = "";
+    values.forEach((_, idx) => {
+      dPts += '<c:dPt><c:idx val="' + idx + '"/><c:bubble3D val="0"/><c:spPr><a:solidFill><a:srgbClr val="' + this.chartColor(idx) + '"/></a:solidFill></c:spPr></c:dPt>';
+    });
+    return '<c:pieChart><c:varyColors val="1"/><c:ser><c:idx val="0"/><c:order val="0"/>' + this.chartSeriesName(series, 0) + dPts + this.chartCatRef(categories, values) + this.chartValRef(values) + '</c:ser><c:firstSliceAng val="0"/></c:pieChart>';
+  }
+  buildScatterChartXml(spec) {
+    let sers = "";
+    spec.series.forEach((series, idx) => {
+      const points = Array.isArray(series.points) ? series.points : [];
+      const xs = [];
+      const ys = [];
+      for (const point of points) {
+        xs.push(toFloat(point.x ?? 0));
+        ys.push(toFloat(point.y ?? 0));
+      }
+      sers += '<c:ser><c:idx val="' + idx + '"/><c:order val="' + idx + '"/>' + this.chartSeriesName(series, idx) + '<c:spPr><a:ln w="19050"><a:noFill/></a:ln></c:spPr><c:marker><c:symbol val="circle"/><c:size val="6"/><c:spPr><a:solidFill><a:srgbClr val="' + this.chartColor(idx) + '"/></a:solidFill></c:spPr></c:marker><c:xVal>' + this.numLit(xs) + "</c:xVal><c:yVal>" + this.numLit(ys) + "</c:yVal></c:ser>";
+    });
+    return '<c:scatterChart><c:scatterStyle val="lineMarker"/><c:varyColors val="0"/>' + sers + '<c:axId val="111111111"/><c:axId val="222222222"/></c:scatterChart><c:valAx><c:axId val="111111111"/><c:scaling><c:orientation val="minMax"/></c:scaling><c:delete val="0"/><c:axPos val="b"/><c:crossAx val="222222222"/></c:valAx><c:valAx><c:axId val="222222222"/><c:scaling><c:orientation val="minMax"/></c:scaling><c:delete val="0"/><c:axPos val="l"/><c:crossAx val="111111111"/></c:valAx>';
+  }
+  buildCatValAxes() {
+    return '<c:catAx><c:axId val="111111111"/><c:scaling><c:orientation val="minMax"/></c:scaling><c:delete val="0"/><c:axPos val="b"/><c:crossAx val="222222222"/></c:catAx><c:valAx><c:axId val="222222222"/><c:scaling><c:orientation val="minMax"/></c:scaling><c:delete val="0"/><c:axPos val="l"/><c:crossAx val="111111111"/></c:valAx>';
+  }
+  chartSeriesName(series, idx) {
+    const name = typeof series.name === "string" && series.name !== "" ? String(series.name) : "Series " + (idx + 1);
+    return "<c:tx><c:strRef><c:f>Sheet1!$A$" + (idx + 1) + '</c:f><c:strCache><c:ptCount val="1"/><c:pt idx="0"><c:v>' + Xml.text(name) + "</c:v></c:pt></c:strCache></c:strRef></c:tx>";
+  }
+  chartSeriesFill(idx) {
+    return '<c:spPr><a:solidFill><a:srgbClr val="' + this.chartColor(idx) + '"/></a:solidFill></c:spPr>';
+  }
+  chartSeriesLine(idx) {
+    return '<c:spPr><a:ln w="28575"><a:solidFill><a:srgbClr val="' + this.chartColor(idx) + '"/></a:solidFill></a:ln></c:spPr>';
+  }
+  chartCatRef(categoriesInput, values) {
+    let categories = categoriesInput;
+    if (categories.length === 0) {
+      categories = [];
+      for (let i = 0; i < values.length; i++) {
+        categories.push(String(i + 1));
+      }
+    }
+    let pts = "";
+    categories.forEach((label, i) => {
+      pts += '<c:pt idx="' + i + '"><c:v>' + Xml.text(String(label)) + "</c:v></c:pt>";
+    });
+    return '<c:cat><c:strLit><c:ptCount val="' + categories.length + '"/>' + pts + "</c:strLit></c:cat>";
+  }
+  chartValRef(values) {
+    return "<c:val>" + this.numLit(values) + "</c:val>";
+  }
+  numLit(values) {
+    let pts = "";
+    values.forEach((value, i) => {
+      pts += '<c:pt idx="' + i + '"><c:v>' + this.numStr(toFloat(value)) + "</c:v></c:pt>";
+    });
+    return '<c:numLit><c:formatCode>General</c:formatCode><c:ptCount val="' + values.length + '"/>' + pts + "</c:numLit>";
+  }
+  numStr(value) {
+    if (value === Math.floor(value) && Math.abs(value) < 1e15) {
+      return String(Math.trunc(value));
+    }
+    return value.toFixed(6).replace(/0+$/, "").replace(/\.$/, "");
+  }
+  chartColor(idx) {
+    if (idx === 0) {
+      return this.themeAccent;
+    }
+    return CHART_PALETTE[idx % CHART_PALETTE.length];
+  }
+  buildChartPlaceholder(label, element, shapeId) {
+    const xfrm = this.xfrmFromFractions(element);
+    const id = element.id ?? `chart-${shapeId}`;
+    return '<p:sp><p:nvSpPr><p:cNvPr id="' + shapeId + '" name="' + Xml.attr(String(id)) + '"/><p:cNvSpPr/><p:nvPr/></p:nvSpPr><p:spPr>' + xfrm + '<a:prstGeom prst="roundRect"><a:avLst/></a:prstGeom><a:solidFill><a:srgbClr val="F1F5F9"/></a:solidFill><a:ln w="12700"><a:solidFill><a:srgbClr val="CBD5E1"/></a:solidFill></a:ln></p:spPr><p:txBody><a:bodyPr wrap="square" anchor="ctr" rtlCol="0"/><a:lstStyle/><a:p><a:pPr algn="ctr"/><a:r><a:rPr lang="en-US" sz="1600" b="1"><a:solidFill><a:srgbClr val="64748B"/></a:solidFill></a:rPr><a:t>' + Xml.text(label) + "</a:t></a:r></a:p></p:txBody></p:sp>";
+  }
+  buildPlaceholder(label, element, shapeId) {
+    return this.buildTextShape(
+      {
+        id: element.id ?? `placeholder-${shapeId}`,
+        type: "text",
+        x: element.x ?? 0.1,
+        y: element.y ?? 0.4,
+        w: element.w ?? 0.8,
+        h: element.h ?? 0.2,
+        content: label,
+        format: "plain",
+        style: { fontSize: 20, align: "center", color: "#64748B" }
+      },
+      shapeId
+    );
+  }
+  // ─── Text body / paragraphs / runs ────────────────────────────────────
+  buildTextBody(content, style, format) {
+    const fontPt = toFloat(style.fontSize ?? 24);
+    const pt = Math.max(8, fontPt / 2);
+    const sz = Emu.hundredthsOfPoint(pt);
+    const baseBold = this.weightToBold(style.weight ?? null);
+    const baseItalic = style.italic ? ' i="1"' : "";
+    const baseUnderline = style.underline ? ' u="sng"' : "";
+    const align = this.alignToAlgn(String(style.align ?? "left"));
+    const [colorHex] = Color.parse(String(style.color ?? "#0F172A"), "0F172A");
+    const fontFamily = style.fontFamily !== void 0 && style.fontFamily !== null ? '<a:latin typeface="' + Xml.attr(String(style.fontFamily)) + '"/>' : "";
+    let anchor;
+    switch (style.verticalAlign ?? "top") {
+      case "middle":
+        anchor = 't="ctr"';
+        break;
+      case "bottom":
+        anchor = 't="b"';
+        break;
+      default:
+        anchor = 't="t"';
+    }
+    const renderRuns = format === "markdown";
+    let paragraphs = "";
+    const lines = content.split("\n");
+    for (const line of lines) {
+      let headingLevel = 0;
+      let isBullet = false;
+      let body = line;
+      if (renderRuns) {
+        [headingLevel, body] = MarkdownInline.headingPrefix(line);
+        if (headingLevel === 0) {
+          [isBullet, body] = MarkdownInline.bulletPrefix(line);
+        }
+      }
+      let paragraphSz = sz;
+      let paragraphBold = baseBold;
+      if (headingLevel > 0) {
+        let multiplier;
+        switch (headingLevel) {
+          case 1:
+            multiplier = 1.8;
+            break;
+          case 2:
+            multiplier = 1.45;
+            break;
+          case 3:
+            multiplier = 1.2;
+            break;
+          default:
+            multiplier = 1;
+        }
+        paragraphSz = Emu.hundredthsOfPoint(pt * multiplier);
+        paragraphBold = ' b="1"';
+      }
+      let pPr = '<a:pPr algn="' + align + '"';
+      if (isBullet) {
+        pPr += ' indent="-228600" marL="228600"><a:buFont typeface="Arial"/><a:buChar char="\u2022"/>';
+      } else {
+        pPr += "><a:buNone/>";
+      }
+      pPr += "</a:pPr>";
+      let runs = "";
+      if (renderRuns) {
+        const tokens = MarkdownInline.tokenize(body);
+        for (const token of tokens) {
+          runs += this.buildRun(
+            token.text,
+            paragraphSz,
+            paragraphBold,
+            baseItalic,
+            baseUnderline,
+            colorHex,
+            fontFamily,
+            token.b,
+            token.i,
+            token.code
+          );
+        }
+      } else {
+        runs = this.buildRun(body, paragraphSz, paragraphBold, baseItalic, baseUnderline, colorHex, fontFamily, false, false, false);
+      }
+      paragraphs += "<a:p>" + pPr + runs + "</a:p>";
+    }
+    return '<p:txBody><a:bodyPr wrap="square" anchor="' + anchor.slice(3, -1) + '" rtlCol="0"/><a:lstStyle/>' + paragraphs + "</p:txBody>";
+  }
+  buildRun(text, sz, baseBold, baseItalic, baseUnderline, colorHex, fontFamily, bold, italic, code) {
+    const b = bold ? ' b="1"' : baseBold;
+    const i = (italic ? ' i="1"' : "") || baseItalic;
+    const u = baseUnderline;
+    let color = colorHex;
+    let family = fontFamily;
+    if (code) {
+      color = "8B5CF6";
+      family = '<a:latin typeface="Consolas"/>';
+    }
+    const rPr = '<a:rPr lang="en-US" sz="' + sz + '"' + b + i + u + '><a:solidFill><a:srgbClr val="' + color + '"/></a:solidFill>' + family + "</a:rPr>";
+    return "<a:r>" + rPr + "<a:t>" + Xml.text(text) + "</a:t></a:r>";
+  }
+  weightToBold(weight) {
+    if (isNumeric(weight) && toInt(weight) >= 600) {
+      return ' b="1"';
+    }
+    if (weight === "bold" || weight === "semibold") {
+      return ' b="1"';
+    }
+    return "";
+  }
+  alignToAlgn(align) {
+    switch (align) {
+      case "center":
+        return "ctr";
+      case "right":
+        return "r";
+      case "justify":
+        return "just";
+      default:
+        return "l";
+    }
+  }
+  // ─── Geometry helper ──────────────────────────────────────────────────
+  xfrmFromFractions(element) {
+    const x = Emu.fromFracX(toFloat(element.x ?? 0));
+    const y = Emu.fromFracY(toFloat(element.y ?? 0));
+    const cx = Emu.fromFracX(toFloat(element.w ?? 0));
+    const cy = Emu.fromFracY(toFloat(element.h ?? 0));
+    const rot = element.rotation !== void 0 ? Math.round(toFloat(element.rotation) * 6e4) : 0;
+    const rotAttr = rot !== 0 ? ' rot="' + rot + '"' : "";
+    return "<a:xfrm" + rotAttr + '><a:off x="' + x + '" y="' + y + '"/><a:ext cx="' + cx + '" cy="' + cy + '"/></a:xfrm>';
+  }
+  // ─── Media staging ────────────────────────────────────────────────────
+  stageMedia(src, _slideNumber) {
+    const data = this.loadImageBytes(src);
+    if (data === null) {
+      return null;
+    }
+    this.mediaCounter++;
+    const i = this.mediaCounter;
+    const ext = this.extensionForMime(data.mime) ?? "png";
+    const archivePath = `ppt/media/image${i}.${ext}`;
+    this.mediaFiles.push({ path: archivePath, bytes: data.bytes });
+    const relId = "rId" + i;
+    return {
+      relId,
+      target: `../media/image${i}.${ext}`,
+      bytes: data.bytes
+    };
+  }
+  loadImageBytes(src) {
+    const m = /^data:([^;,]+)(?:;base64)?,([\s\S]*)$/.exec(src);
+    if (m) {
+      const mime = m[1];
+      const payload = m[2];
+      let bytes;
+      if (src.includes(";base64,")) {
+        try {
+          bytes = base64Decode(payload);
+        } catch {
+          bytes = null;
+        }
+      } else {
+        try {
+          bytes = ENCODER.encode(decodeURIComponent(payload));
+        } catch {
+          bytes = null;
+        }
+      }
+      if (bytes === null) {
+        return null;
+      }
+      return { bytes, mime };
+    }
+    return null;
+  }
+  extensionForMime(mime) {
+    switch (mime) {
+      case "image/png":
+        return "png";
+      case "image/jpeg":
+        return "jpg";
+      case "image/gif":
+        return "gif";
+      case "image/svg+xml":
+        return "svg";
+      case "image/webp":
+        return "webp";
+      default:
+        return null;
+    }
+  }
+  // ─── Slide rels ───────────────────────────────────────────────────────
+  buildSlideRels(slideNumber, hasNotes, layoutNumber = 1) {
+    let rels = "";
+    rels += '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout" Target="../slideLayouts/slideLayout' + layoutNumber + '.xml"/>';
+    let nextRelNum = 2;
+    if (hasNotes) {
+      rels += '<Relationship Id="rId' + nextRelNum + '" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide" Target="../notesSlides/notesSlide' + slideNumber + '.xml"/>';
+      nextRelNum++;
+    }
+    for (const rel of this.pendingSlideRels[slideNumber] ?? []) {
+      const mode = (rel.mode ?? null) === "External" ? ' TargetMode="External"' : "";
+      rels += '<Relationship Id="' + Xml.attr(rel.id) + '" Type="' + Xml.attr(rel.type) + '" Target="' + Xml.attr(rel.target) + '"' + mode + "/>";
+    }
+    return Xml.declaration() + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">' + rels + "</Relationships>";
+  }
+  // ─── Notes slides ─────────────────────────────────────────────────────
+  buildNotesSlideXml(slide, _slideNumber) {
+    const notes = String(slide.notes ?? "");
+    let paragraphs = "";
+    for (const line of notes.split("\n")) {
+      paragraphs += '<a:p><a:r><a:rPr lang="en-US" sz="1200"/><a:t>' + Xml.text(line) + "</a:t></a:r></a:p>";
+    }
+    return Xml.declaration() + '<p:notes 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"><p:cSld><p:spTree><p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/><a:chOff x="0" y="0"/><a:chExt cx="0" cy="0"/></a:xfrm></p:grpSpPr><p:sp><p:nvSpPr><p:cNvPr id="2" name="Notes Placeholder"/><p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr><p:nvPr><p:ph type="body"/></p:nvPr></p:nvSpPr><p:spPr><a:xfrm><a:off x="685800" y="1700213"/><a:ext cx="5772150" cy="3679371"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr><p:txBody><a:bodyPr/><a:lstStyle/>' + paragraphs + "</p:txBody></p:sp></p:spTree></p:cSld></p:notes>";
+  }
+  buildNotesSlideRels(slideNumber) {
+    return Xml.declaration() + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide" Target="../slides/slide' + slideNumber + '.xml"/></Relationships>';
+  }
+};
+function toFloat(v) {
+  if (typeof v === "number") return v;
+  const n = parseFloat(String(v));
+  return Number.isFinite(n) ? n : 0;
+}
+function ucwords(s) {
+  return s.replace(/(^|\s)([a-z])/g, (_m, sp, ch) => sp + ch.toUpperCase());
+}
+function innerXfrm(xfrm) {
+  return xfrm.slice("<a:xfrm>".length, -"</a:xfrm>".length);
+}
+function isScalar2(v) {
+  return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || v === null || typeof v === "bigint";
+}
+function scalarToString(v) {
+  if (v === true) return "1";
+  if (v === false) return "";
+  if (v === null) return "";
+  return String(v);
+}
+function getImageSize(bytes) {
+  if (bytes.length >= 24 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    const w = bytes[16] << 24 | bytes[17] << 16 | bytes[18] << 8 | bytes[19];
+    const h = bytes[20] << 24 | bytes[21] << 16 | bytes[22] << 8 | bytes[23];
+    return [w >>> 0, h >>> 0];
+  }
+  if (bytes.length >= 10 && bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70) {
+    const w = bytes[6] | bytes[7] << 8;
+    const h = bytes[8] | bytes[9] << 8;
+    return [w, h];
+  }
+  if (bytes.length >= 4 && bytes[0] === 255 && bytes[1] === 216) {
+    let i = 2;
+    while (i + 9 < bytes.length) {
+      if (bytes[i] !== 255) {
+        i++;
+        continue;
+      }
+      const marker = bytes[i + 1];
+      if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+        const h = bytes[i + 5] << 8 | bytes[i + 6];
+        const w = bytes[i + 7] << 8 | bytes[i + 8];
+        return [w, h];
+      }
+      const len = bytes[i + 2] << 8 | bytes[i + 3];
+      i += 2 + len;
+    }
+  }
+  return null;
+}
+
+// src/agent.ts
+var VERSION = "0.5.2";
+function toU8(input) {
+  return input instanceof Uint8Array ? input : new Uint8Array(input);
+}
+function makeWriter(options = {}) {
+  return new PptxWriter(options.tempDir ?? null, options.allowHttpImages ?? false);
+}
+function assertValid(deck) {
+  const errors = new Validator().validate(deck);
+  if (errors.length > 0) {
+    throw new SchemaException(
+      "Deck failed schema validation. Call Agent::validateAndRepair() for a recoverable form.",
+      errors
+    );
+  }
+}
+var Agent = {
+  /** Validate a deck without writing. Empty array = valid. */
+  validate(deck) {
+    return new Validator().validate(deck);
+  },
+  /**
+   * Validate + apply heuristic repairs. Returns `{ ok, schema, errors }` where
+   * `ok` is true when the (possibly repaired) deck validates clean.
+   */
+  validateAndRepair(deck) {
+    const errors = this.validate(deck);
+    if (errors.length === 0) {
+      return { ok: true, schema: deck, errors: [] };
+    }
+    const repaired = new Repairer().repair(deck);
+    const remaining = this.validate(repaired);
+    return {
+      ok: remaining.length === 0,
+      schema: repaired,
+      errors: remaining
+    };
+  },
+  /** PPTX bytes for a deck (no temp file). Universal. Throws SchemaException if invalid. */
+  toBytes(deck, options = {}) {
+    assertValid(deck);
+    return makeWriter(options).toBytes(deck);
+  },
+  /** Write a deck to disk as a PPTX file (Node only). Throws SchemaException if invalid. */
+  async write(deck, path, options = {}) {
+    assertValid(deck);
+    const bytes = makeWriter(options).toBytes(deck);
+    const fs = await import('fs');
+    fs.writeFileSync(path, bytes);
+    return { path, bytes: bytes.length, slides: deck?.slides?.length ?? 0 };
+  },
+  /** Read PPTX bytes back into the Deck schema. Universal. */
+  read(input) {
+    return new PptxReader().read(toU8(input));
+  },
+  /** Alias for {@see read}. */
+  fromBytes(input) {
+    return new PptxReader().read(toU8(input));
+  },
+  /** Plain-text summary of a deck. Mirrors PHP `Agent::describe`. */
+  describe(deck) {
+    const title = String(deck?.title ?? "Untitled");
+    const themeName = String(deck?.theme?.name ?? Schema.DEFAULT_THEME_NAME);
+    const slides = deck?.slides ?? [];
+    const slideCount = slides.length;
+    const elementCounts = {};
+    for (const slide of slides) {
+      for (const element of slide?.elements ?? []) {
+        const type = String(element?.type ?? "unknown");
+        elementCounts[type] = (elementCounts[type] ?? 0) + 1;
+      }
+    }
+    const lines = [`Deck: ${title}`, `Theme: ${themeName}`, `Slides: ${slideCount}`];
+    const keys = Object.keys(elementCounts);
+    if (keys.length > 0) {
+      const parts = keys.map((type) => `${elementCounts[type]} ${type}`);
+      lines.push("Elements: " + parts.join(", "));
+    }
+    return lines.join("\n");
+  },
+  /** JSON Schema export for LLM tool-use registration. */
+  jsonSchema() {
+    return Schema.jsonSchema();
+  },
+  version() {
+    return VERSION;
+  }
+};
+
+// src/dark-slide.ts
+var DarkSlide = class {
+  constructor(tempDir = null, allowHttpImages = false) {
+    this.tempDir = tempDir;
+    this.allowHttpImages = allowHttpImages;
+  }
+  validate(deck) {
+    return Agent.validate(deck);
+  }
+  validateAndRepair(deck) {
+    return Agent.validateAndRepair(deck);
+  }
+  async write(deck, path) {
+    return Agent.write(deck, path, { tempDir: this.tempDir ?? void 0, allowHttpImages: this.allowHttpImages });
+  }
+  toBytes(deck) {
+    this.throwIfInvalid(deck);
+    return new PptxWriter(this.tempDir, this.allowHttpImages).toBytes(deck);
+  }
+  throwIfInvalid(deck) {
+    const errors = new Validator().validate(deck);
+    if (errors.length > 0) {
+      throw new SchemaException(
+        "Deck failed schema validation. Call validateAndRepair() for a recoverable form.",
+        errors
+      );
+    }
+  }
+  read(input) {
+    return Agent.read(input);
+  }
+  describe(deck) {
+    return Agent.describe(deck);
+  }
+  jsonSchema() {
+    return Agent.jsonSchema();
+  }
+};
+DarkSlide.VERSION = VERSION;
+
+exports.Agent = Agent;
+exports.DarkSlide = DarkSlide;
+exports.PptxReader = PptxReader;
+exports.PptxWriter = PptxWriter;
+exports.Repairer = Repairer;
+exports.Schema = Schema;
+exports.SchemaException = SchemaException;
+exports.VERSION = VERSION;
+exports.Validator = Validator;
+exports.unzipSync = unzipSync;
+exports.zipSync = zipSync;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map