@taloswork/ose-shared 0.1.11 → 0.1.12

package/skills/document/bin/doc-validate.cjs

@@ -315,7 +315,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join3(s) {
+      BufferList.prototype.join = function join4(s) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret = "" + p.data;
@@ -18354,14 +18354,14 @@ var require_decode = __commonJS({
     var LZWStream_1 = tslib_1.__importDefault(require_LZWStream());
     var RunLengthStream_1 = tslib_1.__importDefault(require_RunLengthStream());
     var Stream_1 = tslib_1.__importDefault(require_Stream());
-    var decodeStream = function(stream, encoding, params) {
+    var decodeStream = function(stream, encoding, params2) {
       if (encoding === PDFName_1.default.of("FlateDecode")) {
         return new FlateStream_1.default(stream);
       }
       if (encoding === PDFName_1.default.of("LZWDecode")) {
         var earlyChange = 1;
-        if (params instanceof PDFDict_1.default) {
-          var EarlyChange = params.lookup(PDFName_1.default.of("EarlyChange"));
+        if (params2 instanceof PDFDict_1.default) {
+          var EarlyChange = params2.lookup(PDFName_1.default.of("EarlyChange"));
           if (EarlyChange instanceof PDFNumber_1.default) {
             earlyChange = EarlyChange.asNumber();
           }
@@ -22243,11 +22243,11 @@ var require_svgPath = __commonJS({
       var args = [];
       var curArg = "";
       var foundDecimal = false;
-      var params = 0;
+      var params2 = 0;
       for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
         var c = path_1[_i];
         if (parameters.has(c)) {
-          params = parameters.get(c);
+          params2 = parameters.get(c);
           if (cmd) {
             if (curArg.length > 0) {
               args[args.length] = +curArg;
@@ -22262,7 +22262,7 @@ var require_svgPath = __commonJS({
           if (curArg.length === 0) {
             continue;
           }
-          if (args.length === params) {
+          if (args.length === params2) {
             ret[ret.length] = { cmd, args };
             args = [+curArg];
             if (cmd === "M") {
@@ -22284,7 +22284,7 @@ var require_svgPath = __commonJS({
         }
       }
       if (curArg.length > 0) {
-        if (args.length === params) {
+        if (args.length === params2) {
           ret[ret.length] = { cmd, args };
           args = [+curArg];
           if (cmd === "M") {
@@ -27581,9 +27581,396 @@ var require_cjs = __commonJS({
   }
 });
 
+// packages/core/dist/document/pdf-encrypted.js
+var ENCRYPTED_PDF_MESSAGE, PdfEncryptedError;
+var init_pdf_encrypted = __esm({
+  "packages/core/dist/document/pdf-encrypted.js"() {
+    "use strict";
+    ENCRYPTED_PDF_MESSAGE = "PDF is password-protected (encrypted); decrypt first: pdf-ops decrypt <in> <password> <out>";
+    PdfEncryptedError = class extends Error {
+      constructor() {
+        super(ENCRYPTED_PDF_MESSAGE);
+        this.name = "PdfEncryptedError";
+      }
+    };
+  }
+});
+
+// packages/core/dist/document/pdf-extract.js
+var pdf_extract_exports = {};
+__export(pdf_extract_exports, {
+  analyzePdfDocument: () => analyzePdfDocument,
+  countVectorOperators: () => countVectorOperators,
+  decryptPdf: () => decryptPdf,
+  encryptPdf: () => encryptPdf,
+  extractPdfImages: () => extractPdfImages,
+  extractPdfTables: () => extractPdfTables,
+  extractPdfText: () => extractPdfText,
+  extractPdfTextLines: () => extractPdfTextLines,
+  pdfNeedsPassword: () => pdfNeedsPassword,
+  renderPdfPages: () => renderPdfPages,
+  scanPdfSignals: () => scanPdfSignals,
+  textMathHint: () => textMathHint,
+  textTableHint: () => textTableHint
+});
+function loadMupdf() {
+  if (!_mupdf) {
+    const deps = process.env.TALOS_SKILL_DEPS;
+    const spec = deps ? (0, import_node_url.pathToFileURL)((0, import_node_path.join)(deps, "mupdf", "dist", "mupdf.js")).href : "mupdf";
+    _mupdf = import(spec);
+  }
+  return _mupdf;
+}
+function textMathHint(text) {
+  if (!text)
+    return false;
+  const hits = (text.match(MATH_CHARS) || []).length;
+  return hits >= 3 || hits / Math.max(text.length, 1) > 0.02;
+}
+function textTableHint(text) {
+  if (!text)
+    return false;
+  const gaps = (text.match(/ {2,}|\t/g) || []).length;
+  return gaps >= 6;
+}
+async function openDoc(bytes) {
+  const mupdf = await loadMupdf();
+  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
+  if (doc.needsPassword())
+    throw new PdfEncryptedError();
+  if (doc.countPages() === 0) {
+    throw new Error("PDF has no readable pages (corrupt, encrypted, or empty)");
+  }
+  return { mupdf, doc };
+}
+async function analyzePdfDocument(bytes, options = {}) {
+  const wantText = options.text !== false;
+  const wantSignals = options.signals === true;
+  const { doc } = await openDoc(bytes);
+  const pageCount = doc.countPages();
+  const signals = [];
+  let out = "";
+  for (let i = 0; i < pageCount; i++) {
+    const page = doc.loadPage(i);
+    if (wantText) {
+      out += `
+[page ${i + 1}]
+${page.toStructuredText().asText()}`;
+    }
+    if (wantSignals) {
+      signals.push(pageSignalsFrom(page, i + 1));
+    }
+  }
+  return { text: wantText ? out.trim() : "", pageCount, signals };
+}
+async function extractPdfText(bytes) {
+  const { text, pageCount } = await analyzePdfDocument(bytes, { text: true });
+  return { text, pageCount };
+}
+function countVectorOperators(content) {
+  let ops = 0;
+  let curves = 0;
+  let fills = 0;
+  let i = 0;
+  const n = content.length;
+  while (i < n) {
+    const ch = content[i];
+    if (ch === "(") {
+      let depth = 1;
+      i++;
+      while (i < n && depth > 0) {
+        if (content[i] === "\\")
+          i++;
+        else if (content[i] === "(")
+          depth++;
+        else if (content[i] === ")")
+          depth--;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "<" && content[i + 1] !== "<") {
+      while (i < n && content[i] !== ">")
+        i++;
+      i++;
+      continue;
+    }
+    if (ch === "I" && content[i + 1] === "D" && isDelimiter(content[i + 2])) {
+      const end = content.indexOf("EI", i + 2);
+      i = end === -1 ? n : end + 2;
+      continue;
+    }
+    if (!isDelimiter(ch)) {
+      const start = i;
+      while (i < n && !isDelimiter(content[i]))
+        i++;
+      const token = content.slice(start, i);
+      switch (token) {
+        case "m":
+        case "l":
+        case "re":
+          ops++;
+          break;
+        case "c":
+        case "v":
+        case "y":
+          ops++;
+          curves++;
+          break;
+        case "f":
+        case "F":
+        case "f*":
+          fills++;
+          break;
+        case "B":
+        case "B*":
+        case "b":
+        case "b*":
+          fills++;
+          break;
+        default:
+          break;
+      }
+      continue;
+    }
+    i++;
+  }
+  return { ops, curves, fills };
+}
+function isDelimiter(ch) {
+  return ch === void 0 || ch === " " || ch === "\n" || ch === "\r" || ch === "	" || ch === "\f" || ch === "\0" || ch === "[" || ch === "]" || ch === "/" || ch === "{" || ch === "}";
+}
+function pageContentStream(page) {
+  try {
+    const obj = page.getObject?.();
+    const contents = obj?.get?.("Contents");
+    if (!contents)
+      return "";
+    const streams = contents.isArray?.() && contents.get ? Array.from({ length: contents.length ?? 0 }, (_, i) => contents.get(i)) : [contents];
+    let out = "";
+    for (const stream of streams) {
+      const buf = stream?.readStream?.();
+      const bytes = buf?.asUint8Array?.();
+      if (bytes)
+        out += Buffer.from(bytes).toString("latin1");
+    }
+    return out;
+  } catch {
+    return "";
+  }
+}
+function pageSignalsFrom(page, pageNumber) {
+  const json = JSON.parse(page.toStructuredText("preserve-images").asJSON());
+  const blocks = json.blocks ?? [];
+  const text = blocks.flatMap((b) => (b.lines ?? []).map((l) => l.text ?? "")).join(" ");
+  const [x0, y0, x1, y1] = page.getBounds();
+  const pageArea = Math.max((x1 - x0) * (y1 - y0), 1);
+  const imgArea = blocks.filter((b) => b.type === "image").reduce((a, b) => a + Math.max((b.bbox?.w ?? 0) * (b.bbox?.h ?? 0), 0), 0);
+  const vector = countVectorOperators(pageContentStream(page));
+  return {
+    page: pageNumber,
+    textChars: text.trim().length,
+    imageCoverage: Math.min(imgArea / pageArea, 1),
+    vectorOps: vector.ops,
+    vectorCurves: vector.curves,
+    vectorFills: vector.fills,
+    mathHint: textMathHint(text),
+    tableHint: textTableHint(text)
+  };
+}
+async function scanPdfSignals(bytes) {
+  const { signals } = await analyzePdfDocument(bytes, { text: false, signals: true });
+  return signals;
+}
+function median(nums) {
+  if (!nums.length)
+    return 0;
+  const s = [...nums].sort((a, b) => a - b);
+  return s[Math.floor(s.length / 2)];
+}
+async function extractPdfTables(bytes, pageNum, minColumns = 2) {
+  const { doc } = await openDoc(bytes);
+  const total = doc.countPages();
+  const from = pageNum ? pageNum : 1;
+  const to = pageNum ? pageNum : total;
+  const out = [];
+  for (let p = from; p <= to; p++) {
+    if (p < 1 || p > total)
+      continue;
+    const json = JSON.parse(doc.loadPage(p - 1).toStructuredText().asJSON());
+    const cells = [];
+    for (const b of json.blocks ?? []) {
+      if (b.type === "image")
+        continue;
+      for (const l of b.lines ?? []) {
+        const text = (l.text ?? "").trim();
+        if (!text)
+          continue;
+        cells.push({ text, x: l.bbox?.x ?? 0, y: l.bbox?.y ?? 0, h: l.bbox?.h ?? 12 });
+      }
+    }
+    if (cells.length < 2)
+      continue;
+    const medH = median(cells.map((c) => c.h)) || 12;
+    const rowTol = Math.max(4, medH * 0.6);
+    const colTol = Math.max(6, medH * 0.9);
+    const byY = [...cells].sort((a, b) => a.y - b.y);
+    const rowGroups = [];
+    let rowRef = Number.NEGATIVE_INFINITY;
+    for (const c of byY) {
+      if (c.y - rowRef > rowTol) {
+        rowGroups.push([]);
+        rowRef = c.y;
+      }
+      rowGroups[rowGroups.length - 1].push(c);
+    }
+    const colRefs = [];
+    for (const x of cells.map((c) => c.x).sort((a, b) => a - b)) {
+      if (!colRefs.length || x - colRefs[colRefs.length - 1] > colTol)
+        colRefs.push(x);
+    }
+    const colIndex = (x) => {
+      let best = 0, bd = Infinity;
+      colRefs.forEach((r, i) => {
+        const d = Math.abs(x - r);
+        if (d < bd) {
+          bd = d;
+          best = i;
+        }
+      });
+      return best;
+    };
+    const rows = [];
+    for (const group of rowGroups) {
+      const arr = Array(colRefs.length).fill("");
+      for (const c of group.sort((a, b) => a.x - b.x)) {
+        const i = colIndex(c.x);
+        arr[i] = arr[i] ? `${arr[i]} ${c.text}` : c.text;
+      }
+      if (arr.filter((v) => v).length >= minColumns)
+        rows.push(arr);
+    }
+    if (rows.length)
+      out.push({ page: p, rows });
+  }
+  return out;
+}
+async function extractPdfTextLines(bytes) {
+  const { doc } = await openDoc(bytes);
+  const out = [];
+  for (let p = 1; p <= doc.countPages(); p++) {
+    const page = doc.loadPage(p - 1);
+    const [x0, y0, x1, y1] = page.getBounds();
+    const json = JSON.parse(page.toStructuredText().asJSON());
+    const lines = [];
+    for (const b of json.blocks ?? []) {
+      if (b.type === "image")
+        continue;
+      for (const l of b.lines ?? []) {
+        const text = l.text ?? "";
+        if (!text.trim() || !l.bbox)
+          continue;
+        lines.push({
+          x: l.bbox.x ?? 0,
+          y: l.bbox.y ?? 0,
+          w: l.bbox.w ?? 0,
+          h: l.bbox.h ?? 0,
+          size: l.font?.size ?? 12,
+          text
+        });
+      }
+    }
+    out.push({ page: p, width: x1 - x0, height: y1 - y0, lines });
+  }
+  return out;
+}
+async function renderPdfPages(bytes, pages, scale = 2, maxEdge) {
+  const { mupdf, doc } = await openDoc(bytes);
+  const total = doc.countPages();
+  const wanted = pages === "all" ? Array.from({ length: total }, (_, i) => i + 1) : pages;
+  const out = [];
+  for (const p of wanted) {
+    if (p < 1 || p > total)
+      continue;
+    const page = doc.loadPage(p - 1);
+    const [x0, y0, x1, y1] = page.getBounds();
+    const longest = Math.max(x1 - x0, y1 - y0);
+    const s = maxEdge && longest > 0 ? Math.min(scale, maxEdge / longest) : scale;
+    const pix = page.toPixmap(mupdf.Matrix.scale(s, s), mupdf.ColorSpace.DeviceRGB, false, true);
+    out.push({ page: p, png: pix.asPNG() });
+  }
+  return out;
+}
+async function extractPdfImages(bytes, pages) {
+  const { doc } = await openDoc(bytes);
+  const total = doc.countPages();
+  const wanted = pages && pages.length ? pages : Array.from({ length: total }, (_, i) => i + 1);
+  const images = [];
+  let skipped = 0;
+  for (const p of wanted) {
+    if (p < 1 || p > total)
+      continue;
+    const stext = doc.loadPage(p - 1).toStructuredText("preserve-images");
+    let index = 0;
+    stext.walk({
+      onImageBlock(bbox, _matrix, image) {
+        const slot = index++;
+        try {
+          const png = image.toPixmap().asPNG();
+          images.push({
+            page: p,
+            index: slot,
+            bbox: [bbox[0], bbox[1], bbox[2], bbox[3]],
+            width: image.getWidth(),
+            height: image.getHeight(),
+            png
+          });
+        } catch {
+          skipped++;
+        }
+      }
+    });
+  }
+  return { images, skipped };
+}
+async function encryptPdf(bytes, userPassword, ownerPassword) {
+  if (!userPassword)
+    throw new Error("a non-empty user password is required");
+  const { doc } = await openDoc(bytes);
+  const opts = `encrypt=aes-256,user-password=${userPassword},owner-password=${ownerPassword || userPassword}`;
+  return doc.saveToBuffer(opts).asUint8Array();
+}
+async function pdfNeedsPassword(bytes) {
+  const mupdf = await loadMupdf();
+  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
+  return doc.needsPassword();
+}
+async function decryptPdf(bytes, password) {
+  const mupdf = await loadMupdf();
+  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
+  if (doc.needsPassword()) {
+    if (doc.authenticatePassword(password) === 0)
+      throw new Error("wrong password");
+  }
+  if (doc.countPages() === 0)
+    throw new Error("PDF has no readable pages (corrupt or empty)");
+  return doc.saveToBuffer("encrypt=none").asUint8Array();
+}
+var import_node_path, import_node_url, _mupdf, MATH_CHARS;
+var init_pdf_extract = __esm({
+  "packages/core/dist/document/pdf-extract.js"() {
+    "use strict";
+    import_node_path = require("node:path");
+    import_node_url = require("node:url");
+    init_pdf_encrypted();
+    _mupdf = null;
+    MATH_CHARS = /[=∑∫√≤≥≠±∞πθλμσΩ×÷∂∇→←↔∈∉⊂⊃∀∃]/g;
+  }
+});
+
 // apps/admin/data/skills.lib/document/bin-src/doc-validate.mjs
 var import_promises2 = require("node:fs/promises");
-var import_node_path2 = require("node:path");
+var import_node_path3 = require("node:path");
 
 // packages/core/dist/document/doc-validate.js
 var import_jszip = __toESM(require_lib3(), 1);
@@ -27599,6 +27986,17 @@ async function validatePdf(bytes) {
   try {
     const doc = await import_pdf_lib.PDFDocument.load(bytes, { ignoreEncryption: true, throwOnInvalidObject: true, updateMetadata: false });
     pages = doc.getPageCount();
+    if (doc.isEncrypted) {
+      const { pdfNeedsPassword: pdfNeedsPassword2 } = await Promise.resolve().then(() => (init_pdf_extract(), pdf_extract_exports));
+      if (await pdfNeedsPassword2(bytes).catch(() => true)) {
+        errors.push({
+          code: "pdf-encrypted",
+          message: "the PDF needs a password to open, so its content cannot be checked or rendered \u2014 validate (and render) the unencrypted file before `pdf-ops encrypt`; to inspect this one, `pdf-ops decrypt <in> <password> <out>` first"
+        });
+        return { ok: false, kind: "pdf", errors, warnings, pages };
+      }
+      warnings.push({ code: "pdf-encrypted", message: 'the PDF is encrypted with an owner password only: it opens without a password, but pdf-form / pdf-ops cannot edit it until `pdf-ops decrypt <in> "" <out>`' });
+    }
     if (pages === 0)
       errors.push({ code: "pdf-no-pages", message: "the PDF parses but has no pages" });
     else
@@ -27828,15 +28226,15 @@ async function validateOoxml(bytes) {
 }
 
 // packages/core/dist/document/doc-xsd.js
-var import_node_path = require("node:path");
-var import_node_url = require("node:url");
+var import_node_path2 = require("node:path");
+var import_node_url2 = require("node:url");
 var import_promises = require("node:fs/promises");
 var import_jszip2 = __toESM(require_lib3(), 1);
 var _xmllint = null;
 function loadXmllint() {
   if (!_xmllint) {
     const deps = process.env.TALOS_SKILL_DEPS;
-    const spec = deps ? (0, import_node_url.pathToFileURL)((0, import_node_path.join)(deps, "xmllint-wasm", "index-node.js")).href : "xmllint-wasm";
+    const spec = deps ? (0, import_node_url2.pathToFileURL)((0, import_node_path2.join)(deps, "xmllint-wasm", "index-node.js")).href : "xmllint-wasm";
     _xmllint = import(spec);
   }
   return _xmllint;
@@ -27879,7 +28277,7 @@ async function loadSchemaSet(schemaDir) {
   if (!files.length)
     throw new Error(`no .xsd schemas found in ${schemaDir}`);
   const set = /* @__PURE__ */ new Map();
-  await Promise.all(files.map(async (f) => set.set(f, await (0, import_promises.readFile)((0, import_node_path.join)(schemaDir, f), "utf8"))));
+  await Promise.all(files.map(async (f) => set.set(f, await (0, import_promises.readFile)((0, import_node_path2.join)(schemaDir, f), "utf8"))));
   return set;
 }
 function errText(e) {
@@ -27983,6 +28381,118 @@ async function slidePartsInOrder(zip) {
   return toParts(complete ? ordered : byNumber);
 }
 
+// packages/core/dist/document/png-decode.js
+var import_node_zlib = require("node:zlib");
+var SIG = [137, 80, 78, 71, 13, 10, 26, 10];
+var CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
+function decodePng(bytes) {
+  try {
+    if (bytes.length < 33 || SIG.some((b, i) => bytes[i] !== b))
+      return void 0;
+    const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let width = 0, height = 0, depth = 0, type = -1, interlace = 0;
+    let palette;
+    const idat = [];
+    for (let p = 8; p + 8 <= buf.length; ) {
+      const len = buf.readUInt32BE(p);
+      const kind = buf.toString("latin1", p + 4, p + 8);
+      const data = buf.subarray(p + 8, p + 8 + len);
+      if (kind === "IHDR") {
+        width = data.readUInt32BE(0);
+        height = data.readUInt32BE(4);
+        depth = data[8];
+        type = data[9];
+        interlace = data[12];
+      } else if (kind === "PLTE")
+        palette = data;
+      else if (kind === "IDAT")
+        idat.push(data);
+      else if (kind === "IEND")
+        break;
+      p += 12 + len;
+    }
+    const ch = CHANNELS[type];
+    if (!width || !height || depth !== 8 || interlace !== 0 || ch === void 0 || type === 3 && !palette)
+      return void 0;
+    const raw = (0, import_node_zlib.inflateSync)(Buffer.concat(idat));
+    const stride = width * ch;
+    if (raw.length < height * (stride + 1))
+      return void 0;
+    const cur = new Uint8Array(stride);
+    const prev = new Uint8Array(stride);
+    const rgb = new Uint8Array(width * height * 3);
+    for (let y = 0; y < height; y++) {
+      const off = y * (stride + 1);
+      const filter = raw[off];
+      for (let i = 0; i < stride; i++) {
+        const x = raw[off + 1 + i];
+        const a = i >= ch ? cur[i - ch] : 0;
+        const b = prev[i];
+        const c = i >= ch ? prev[i - ch] : 0;
+        let v;
+        switch (filter) {
+          case 0:
+            v = x;
+            break;
+          case 1:
+            v = x + a;
+            break;
+          case 2:
+            v = x + b;
+            break;
+          case 3:
+            v = x + (a + b >> 1);
+            break;
+          case 4: {
+            const pa = Math.abs(b - c), pb = Math.abs(a - c), pc = Math.abs(a + b - 2 * c);
+            v = x + (pa <= pb && pa <= pc ? a : pb <= pc ? b : c);
+            break;
+          }
+          default:
+            return void 0;
+        }
+        cur[i] = v & 255;
+      }
+      for (let px = 0; px < width; px++) {
+        const o = (y * width + px) * 3;
+        const s = px * ch;
+        if (type === 3) {
+          const k = cur[s] * 3;
+          rgb[o] = palette[k];
+          rgb[o + 1] = palette[k + 1];
+          rgb[o + 2] = palette[k + 2];
+        } else if (ch <= 2) {
+          rgb[o] = rgb[o + 1] = rgb[o + 2] = cur[s];
+        } else {
+          rgb[o] = cur[s];
+          rgb[o + 1] = cur[s + 1];
+          rgb[o + 2] = cur[s + 2];
+        }
+      }
+      prev.set(cur);
+    }
+    return { width, height, rgb };
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/core/dist/document/text-slack.js
+var SLACK_CJK_RE = /[\u3000-\u303F\u3400-\u9FFF\uF900-\uFAFF\uFF00-\uFFEF]/;
+var PCT = { single: { cjk: 0.22, latin: 0.16 }, multi: { cjk: 0.1, latin: 0.06 } };
+var FLOOR_EM = { cjk: 1, latin: 0.45 };
+function params(single, cjk) {
+  const script = cjk ? "cjk" : "latin";
+  return { pct: PCT[single ? "single" : "multi"][script], floor: FLOOR_EM[script] * (single ? 1 : 0.5) };
+}
+function unpaddedWidth(padded, fontSize, single, cjk) {
+  const { pct, floor } = params(single, cjk);
+  const floorAbs = floor * fontSize;
+  const viaPct = padded / (1 + pct);
+  return viaPct * pct >= floorAbs ? viaPct : Math.max(0, padded - floorAbs);
+}
+var CHART_TEXT_NAME = "talos-chart-text";
+
 // packages/core/dist/document/doc-design-lint.js
 var PLACEHOLDER_RE = /替换为|在这里写|占位|示例文本|Lorem ipsum/i;
 var CJK_TEXT_RE = /[぀-ヿ㐀-䶿一-鿿가-힯豈-﫿]/;
@@ -28123,7 +28633,7 @@ function lintSlideXml(slideXml, slideNumber, masterBg, expectedLang = detectDeck
       }
     }
   }
-  if (worst && !worst.onShapeFill && anyVisualShape)
+  if (worst && !worst.onShapeFill && (anyVisualShape || hasPic))
     worst = void 0;
   if (placeholder) {
     const snippet = placeholder.length > 24 ? `${placeholder.slice(0, 24)}\u2026` : placeholder;
@@ -28163,7 +28673,10 @@ var EMU_PER_INCH = 914400;
 var DEFAULT_CANVAS = { w: 12192e3, h: 6858e3 };
 var OFFCANVAS_TOL = EMU_PER_INCH / 10;
 var MIN_FONT_HUNDREDTHS = 1e3;
-var OVERLAP_RATIO = 0.5;
+var LABEL_MAX_CHARS = 24;
+var MIN_LABEL_FONT_HUNDREDTHS = 800;
+var CHART_TEXT_RE = new RegExp(`<p:cNvPr\\b[^>]*\\bname="${CHART_TEXT_NAME}\\b`);
+var OVERLAP_RATIO = 0.3;
 function firstBox(block) {
   const xf = /<(?:a|p):xfrm\b[^>]*>[\s\S]*?<\/(?:a|p):xfrm>/.exec(block);
   const scope = xf ? xf[0] : block;
@@ -28181,6 +28694,51 @@ function overlapArea(a, b) {
   const iy = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
   return ix * iy;
 }
+var CJK_WIDE_RE = /[\u2E80-\u9FFF\uAC00-\uD7AF\uF900-\uFAFF\uFF00-\uFFEF]/;
+var EMU_PER_PT = 12700;
+function inkBox(block, box) {
+  let maxSz = 0;
+  let inkW = 0;
+  let lines = 0;
+  for (const para of block.match(/<a:p>[\s\S]*?<\/a:p>|<a:p\b[^>]*>[\s\S]*?<\/a:p>/g) ?? []) {
+    let paraW = 0;
+    let paraSz = 0;
+    for (const run of para.match(/<a:r>[\s\S]*?<\/a:r>/g) ?? []) {
+      const raw = /<a:t\b[^>]*>([\s\S]*?)<\/a:t>/.exec(run)?.[1];
+      if (raw === void 0)
+        continue;
+      const sz = +(/<a:rPr\b[^>]*\bsz="(\d+)"/.exec(run)?.[1] ?? 1800) / 100;
+      paraSz = Math.max(paraSz, sz);
+      for (const ch of unescXml(raw))
+        paraW += (CJK_WIDE_RE.test(ch) ? 1 : ch === " " ? 0.3 : 0.55) * sz * EMU_PER_PT;
+    }
+    if (!paraW)
+      continue;
+    maxSz = Math.max(maxSz, paraSz);
+    const paraLines = box.w > 0 ? Math.max(1, Math.ceil(paraW / box.w)) : 1;
+    lines += paraLines;
+    inkW = Math.max(inkW, Math.min(paraW, box.w));
+  }
+  if (!lines)
+    return void 0;
+  const paras = (block.match(/<a:p>[\s\S]*?<\/a:p>|<a:p\b[^>]*>[\s\S]*?<\/a:p>/g) ?? []).filter((p) => /<a:t\b[^>]*>[^<]*\S/.test(p));
+  if (paras.length === 1 && maxSz > 0) {
+    const lnSpc = /<a:lnSpc>\s*<a:spcPts\b[^>]*\bval="(\d+)"/.exec(block)?.[1];
+    const lineH = (lnSpc ? +lnSpc / 100 : maxSz * 1.3) * EMU_PER_PT;
+    const clamped = box.x + box.w >= DEFAULT_CANVAS.w - EMU_PER_PT;
+    if (box.h <= lineH * 1.5 && !clamped) {
+      const text = unescXml((block.match(/<a:t\b[^>]*>([\s\S]*?)<\/a:t>/g) ?? []).join(""));
+      lines = 1;
+      inkW = Math.min(inkW, unpaddedWidth(box.w, maxSz * EMU_PER_PT, true, SLACK_CJK_RE.test(text)));
+    }
+  }
+  const inkH = Math.min(box.h, lines * maxSz * 1.2 * EMU_PER_PT);
+  const algn = /<a:pPr\b[^>]*\balgn="(\w+)"/.exec(block)?.[1];
+  const anchor = /<a:bodyPr\b[^>]*\banchor="(\w+)"/.exec(block)?.[1];
+  const x = algn === "ctr" ? box.x + (box.w - inkW) / 2 : algn === "r" ? box.x + box.w - inkW : box.x;
+  const y = anchor === "ctr" ? box.y + (box.h - inkH) / 2 : anchor === "b" ? box.y + box.h - inkH : box.y;
+  return { x, y, w: inkW, h: inkH };
+}
 function lintSlideGeometry(slideXml, slideNumber, canvas = DEFAULT_CANVAS) {
   const findings = [];
   const blocks = slideXml.match(/<p:(?:sp|pic|graphicFrame|cxnSp)\b[^>]*>[\s\S]*?<\/p:(?:sp|pic|graphicFrame|cxnSp)>/g) ?? [];
@@ -28204,16 +28762,23 @@ function lintSlideGeometry(slideXml, slideNumber, canvas = DEFAULT_CANVAS) {
             worstOff = { by, edge };
         }
       }
-      if (hasText && box.w > 0 && box.h > 0)
-        textBoxes.push(box);
+      if (hasText && box.w > 0 && box.h > 0) {
+        const ink = inkBox(b, box);
+        if (ink)
+          textBoxes.push(ink);
+      }
     }
+    if (CHART_TEXT_RE.test(b))
+      continue;
     for (const run of b.match(/<a:r>[\s\S]*?<\/a:r>/g) ?? []) {
       const raw = /<a:t\b[^>]*>([\s\S]*?)<\/a:t>/.exec(run)?.[1];
       if (raw === void 0 || !unescXml(raw).trim())
         continue;
+      const text = unescXml(raw).trim();
       const sz = /<a:rPr\b[^>]*\bsz="(\d+)"/.exec(run)?.[1];
-      if (sz && +sz < MIN_FONT_HUNDREDTHS && (!smallest || +sz < smallest.sz)) {
-        smallest = { sz: +sz, text: unescXml(raw).trim() };
+      const floor = [...text].length <= LABEL_MAX_CHARS ? MIN_LABEL_FONT_HUNDREDTHS : MIN_FONT_HUNDREDTHS;
+      if (sz && +sz < floor && (!smallest || +sz < smallest.sz)) {
+        smallest = { sz: +sz, text, floor };
       }
     }
   }
@@ -28229,7 +28794,7 @@ function lintSlideGeometry(slideXml, slideNumber, canvas = DEFAULT_CANVAS) {
     findings.push({
       slide: slideNumber,
       code: "tiny-font",
-      message: `text "${snippet}" is ${(smallest.sz / 100).toFixed(0)}pt \u2014 below the ~10pt readable floor for a projected slide; enlarge it or cut the text`
+      message: `text "${snippet}" is ${+(smallest.sz / 100).toFixed(1)}pt \u2014 below the ~${smallest.floor / 100}pt readable floor for ${smallest.floor < MIN_FONT_HUNDREDTHS ? "a short label" : "text"} on a projected slide; enlarge it or cut the text`
     });
   }
   let worstPair;
@@ -28254,6 +28819,110 @@ function lintSlideGeometry(slideXml, slideNumber, canvas = DEFAULT_CANVAS) {
   }
   return findings;
 }
+var BACKDROP_COVER = 0.98;
+var BACKDROP_FLOOR = 2;
+var BACKDROP_SAMPLES = 2500;
+var LIN = Array.from({ length: 256 }, (_, i) => {
+  const c = i / 255;
+  return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+});
+var lumRgb = (r, g, b) => 0.2126 * LIN[r] + 0.7152 * LIN[g] + 0.0722 * LIN[b];
+var ratioOf = (a, b) => (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
+var hex2 = (n) => n.toString(16).padStart(2, "0").toUpperCase();
+var BLOCK_RE = /<p:(?:sp|pic|graphicFrame|cxnSp)\b[^>]*>[\s\S]*?<\/p:(?:sp|pic|graphicFrame|cxnSp)>/g;
+function backdropPicEmbed(slideXml, canvas = DEFAULT_CANVAS) {
+  const first = (slideXml.match(BLOCK_RE) ?? [])[0];
+  if (!first || !first.startsWith("<p:pic"))
+    return void 0;
+  const box = firstBox(first);
+  if (!box || box.x > canvas.w * (1 - BACKDROP_COVER) || box.y > canvas.h * (1 - BACKDROP_COVER))
+    return void 0;
+  if (box.w < canvas.w * BACKDROP_COVER || box.h < canvas.h * BACKDROP_COVER)
+    return void 0;
+  return /<a:blip\b[^>]*\br:embed="([^"]+)"/.exec(first)?.[1];
+}
+function lintBackdropContrast(slideXml, slideNumber, backdrop, canvas = DEFAULT_CANVAS) {
+  const blocks = slideXml.match(BLOCK_RE) ?? [];
+  const sx = backdrop.width / canvas.w;
+  const sy = backdrop.height / canvas.h;
+  const occluders = [];
+  let worst;
+  for (let bi = 1; bi < blocks.length; bi++) {
+    const b = blocks[bi];
+    const box = firstBox(b);
+    if (!box)
+      continue;
+    const txIdx = b.indexOf("<p:txBody>");
+    const spPr = txIdx >= 0 ? b.slice(0, txIdx) : b;
+    const prst = /<a:prstGeom\b[^>]*\bprst="([^"]+)"/.exec(spPr)?.[1];
+    const visual = !b.startsWith("<p:sp") || FILL_RE.test(spPr) || prst !== void 0 && prst !== "rect";
+    const hasText = txIdx >= 0 && /<a:t\b[^>]*>\s*\S/.test(b);
+    if (visual) {
+      occluders.push(box);
+      continue;
+    }
+    if (!hasText)
+      continue;
+    const ink = inkBox(b, box);
+    if (!ink || ink.w <= 0 || ink.h <= 0)
+      continue;
+    if (occluders.some((o2) => overlapArea(o2, ink) > 0))
+      continue;
+    let fg;
+    let alpha = 1;
+    let text = "";
+    for (const run of b.match(/<a:r>[\s\S]*?<\/a:r>/g) ?? []) {
+      const raw = /<a:t\b[^>]*>([\s\S]*?)<\/a:t>/.exec(run)?.[1];
+      if (raw === void 0 || !unescXml(raw).trim())
+        continue;
+      text += unescXml(raw);
+      if (fg)
+        continue;
+      const rPr = run.slice(0, Math.max(0, run.indexOf("</a:rPr>")));
+      fg = firstSrgb(rPr);
+      const a = /<a:srgbClr\b[^>]*>\s*<a:alpha\b[^>]*\bval="(\d+)"/.exec(rPr)?.[1];
+      if (fg && a)
+        alpha = Math.min(1, +a / 1e5);
+    }
+    if (!fg)
+      continue;
+    const x0 = Math.max(0, Math.floor(ink.x * sx));
+    const y0 = Math.max(0, Math.floor(ink.y * sy));
+    const x1 = Math.min(backdrop.width, Math.ceil((ink.x + ink.w) * sx));
+    const y1 = Math.min(backdrop.height, Math.ceil((ink.y + ink.h) * sy));
+    if (x1 <= x0 || y1 <= y0)
+      continue;
+    const step = Math.max(1, Math.floor(Math.sqrt((x1 - x0) * (y1 - y0) / BACKDROP_SAMPLES)));
+    const fr = parseInt(fg.slice(0, 2), 16), fgG = parseInt(fg.slice(2, 4), 16), fb = parseInt(fg.slice(4, 6), 16);
+    const fgLum = lumRgb(fr, fgG, fb);
+    const samples = [];
+    for (let y = y0; y < y1; y += step) {
+      for (let x = x0; x < x1; x += step) {
+        const o2 = (y * backdrop.width + x) * 3;
+        const r = backdrop.rgb[o2], g = backdrop.rgb[o2 + 1], bl = backdrop.rgb[o2 + 2];
+        const l = lumRgb(r, g, bl);
+        const tl = alpha >= 1 ? fgLum : lumRgb(Math.round(alpha * fr + (1 - alpha) * r), Math.round(alpha * fgG + (1 - alpha) * g), Math.round(alpha * fb + (1 - alpha) * bl));
+        samples.push([ratioOf(tl, l), o2]);
+      }
+    }
+    if (!samples.length)
+      continue;
+    samples.sort((p, q) => p[0] - q[0]);
+    const [ratio, o] = samples[samples.length >> 1];
+    if (ratio < BACKDROP_FLOOR && (!worst || ratio < worst.ratio)) {
+      const bg = hex2(backdrop.rgb[o]) + hex2(backdrop.rgb[o + 1]) + hex2(backdrop.rgb[o + 2]);
+      worst = { ratio, text: text.trim(), fg, bg };
+    }
+  }
+  if (!worst)
+    return [];
+  const snippet = worst.text.length > 24 ? `${worst.text.slice(0, 24)}\u2026` : worst.text;
+  return [{
+    slide: slideNumber,
+    code: "low-contrast-text",
+    message: `text "${snippet}" is #${worst.fg} over the slide's rendered background (\u2248#${worst.bg} under it) \u2014 median contrast ${worst.ratio.toFixed(1)}:1, below the ${BACKDROP_FLOOR.toFixed(1)} floor \u2014 it can barely be seen; text over a photo or panel takes that surface's text colour (light on a dark photo/scrim), not the skin's page text colour`
+  }];
+}
 function canvasFromPresentation(xml) {
   if (!xml)
     return DEFAULT_CANVAS;
@@ -28261,6 +28930,26 @@ function canvasFromPresentation(xml) {
   const cy = /<p:sldSz\b[^>]*\bcy="(\d+)"/.exec(xml)?.[1];
   return cx && cy ? { w: +cx, h: +cy } : DEFAULT_CANVAS;
 }
+async function backdropRaster(zip, slideXml, relsPath, canvas) {
+  const rId = backdropPicEmbed(slideXml, canvas);
+  const rels = rId ? zip.file(relsPath) : null;
+  if (!rId || !rels)
+    return void 0;
+  const relsXml = await rels.async("string");
+  const rel = [...relsXml.matchAll(/<Relationship\b[^>]*>/g)].map((m) => m[0]).find((r) => new RegExp(`\\bId="${rId}"`).test(r));
+  const target = rel && /\bTarget="([^"]+)"/.exec(rel)?.[1];
+  if (!target || !/\.png$/i.test(target))
+    return void 0;
+  const parts = ["ppt", "slides"];
+  for (const seg of target.split("/")) {
+    if (seg === "..")
+      parts.pop();
+    else if (seg && seg !== ".")
+      parts.push(seg);
+  }
+  const media = zip.file(target.startsWith("/") ? target.slice(1) : parts.join("/"));
+  return media ? decodePng(await media.async("uint8array")) : void 0;
+}
 async function designLintPptx(bytes) {
   const zip = await import_jszip3.default.loadAsync(Buffer.from(bytes));
   const findings = [];
@@ -28271,9 +28960,15 @@ async function designLintPptx(bytes) {
   const presFile = zip.file("ppt/presentation.xml");
   const canvas = canvasFromPresentation(presFile ? await presFile.async("string") : void 0);
   const lang = detectDeckLang();
-  for (const { position, path } of await slidePartsInOrder(zip)) {
+  for (const { position, path, relsPath } of await slidePartsInOrder(zip)) {
     const xml = await zip.file(path).async("string");
-    findings.push(...lintSlideXml(xml, position, masterBg, lang));
+    const own = lintSlideXml(xml, position, masterBg, lang);
+    findings.push(...own);
+    if (!own.some((f) => f.code === "low-contrast-text")) {
+      const backdrop = await backdropRaster(zip, xml, relsPath, canvas);
+      if (backdrop)
+        findings.push(...lintBackdropContrast(xml, position, backdrop, canvas));
+    }
     findings.push(...lintSlideGeometry(xml, position, canvas));
   }
   return { ok: findings.length === 0, findings };
@@ -28302,7 +28997,7 @@ async function main() {
     }];
   }
   if (strict && strictApplies) {
-    const schemaDir = process.env.TALOS_XSD_DIR || (0, import_node_path2.join)((0, import_node_path2.dirname)(process.argv[1]), "..", "schemas");
+    const schemaDir = process.env.TALOS_XSD_DIR || (0, import_node_path3.join)((0, import_node_path3.dirname)(process.argv[1]), "..", "schemas");
     strictResult = await validateOoxmlStrict(bytes, schemaDir).catch((e) => {
       die(`--strict failed to run: ${e.message}`);
     });