@taloswork/ose-shared 0.1.10 → 0.1.12

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

@@ -4320,7 +4320,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join4(s) {
+      BufferList.prototype.join = function join5(s) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret2 = "" + p.data;
@@ -13959,7 +13959,7 @@ var require_buffer_list2 = __commonJS({
         }
       }, {
         key: "join",
-        value: function join4(s) {
+        value: function join5(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret2 = "" + p.data;
@@ -41204,7 +41204,7 @@ var require_buffer_list3 = __commonJS({
         }
       }, {
         key: "join",
-        value: function join4(s) {
+        value: function join5(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret2 = "" + p.data;
@@ -44570,7 +44570,7 @@ var require_buffer_list4 = __commonJS({
         }
       }, {
         key: "join",
-        value: function join4(s) {
+        value: function join5(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret2 = "" + p.data;
@@ -47366,7 +47366,7 @@ var require_buffer_list5 = __commonJS({
         }
       }, {
         key: "join",
-        value: function join4(s) {
+        value: function join5(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret2 = "" + p.data;
@@ -50236,7 +50236,7 @@ var require_buffer_list6 = __commonJS({
         }
       }, {
         key: "join",
-        value: function join4(s) {
+        value: function join5(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret2 = "" + p.data;
@@ -53025,7 +53025,7 @@ var require_buffer_list7 = __commonJS({
         }
       }, {
         key: "join",
-        value: function join4(s) {
+        value: function join5(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret2 = "" + p.data;
@@ -56015,7 +56015,7 @@ var require_buffer_list8 = __commonJS({
         }
       }, {
         key: "join",
-        value: function join4(s) {
+        value: function join5(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret2 = "" + p.data;
@@ -66273,7 +66273,7 @@ var require_BufferList3 = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join4(s) {
+      BufferList.prototype.join = function join5(s) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret2 = "" + p.data;
@@ -90687,6 +90687,393 @@ 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 obj2 = page.getObject?.();
+    const contents = obj2?.get?.("Contents");
+    if (!contents)
+      return "";
+    const streams = contents.isArray?.() && contents.get ? Array.from({ length: contents.length ?? 0 }, (_2, 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((l2) => l2.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 l2 of b.lines ?? []) {
+        const text = (l2.text ?? "").trim();
+        if (!text)
+          continue;
+        cells.push({ text, x: l2.bbox?.x ?? 0, y: l2.bbox?.y ?? 0, h: l2.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 l2 of b.lines ?? []) {
+        const text = l2.text ?? "";
+        if (!text.trim() || !l2.bbox)
+          continue;
+        lines.push({
+          x: l2.bbox.x ?? 0,
+          y: l2.bbox.y ?? 0,
+          w: l2.bbox.w ?? 0,
+          h: l2.bbox.h ?? 0,
+          size: l2.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 }, (_2, 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 }, (_2, 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-gen.mjs
 var import_promises2 = require("node:fs/promises");
 
@@ -94311,7 +94698,7 @@ var require_buffer_list = /* @__PURE__ */ __commonJSMin(((exports2, module2) =>
       },
       {
         key: "join",
-        value: function join4(s) {
+        value: function join5(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret2 = "" + p.data;
@@ -98748,6 +99135,46 @@ var createShading = ({ fill, color, type }) => new BuilderElement({
     }
   }
 });
+var ShadingType = {
+  /** Clear shading - no pattern, fill color only */
+  CLEAR: "clear",
+  DIAGONAL_CROSS: "diagCross",
+  DIAGONAL_STRIPE: "diagStripe",
+  HORIZONTAL_CROSS: "horzCross",
+  HORIZONTAL_STRIPE: "horzStripe",
+  NIL: "nil",
+  PERCENT_5: "pct5",
+  PERCENT_10: "pct10",
+  PERCENT_12: "pct12",
+  PERCENT_15: "pct15",
+  PERCENT_20: "pct20",
+  PERCENT_25: "pct25",
+  PERCENT_30: "pct30",
+  PERCENT_35: "pct35",
+  PERCENT_37: "pct37",
+  PERCENT_40: "pct40",
+  PERCENT_45: "pct45",
+  PERCENT_50: "pct50",
+  PERCENT_55: "pct55",
+  PERCENT_60: "pct60",
+  PERCENT_62: "pct62",
+  PERCENT_65: "pct65",
+  PERCENT_70: "pct70",
+  PERCENT_75: "pct75",
+  PERCENT_80: "pct80",
+  PERCENT_85: "pct85",
+  PERCENT_87: "pct87",
+  PERCENT_90: "pct90",
+  PERCENT_95: "pct95",
+  REVERSE_DIAGONAL_STRIPE: "reverseDiagStripe",
+  SOLID: "solid",
+  THIN_DIAGONAL_CROSS: "thinDiagCross",
+  THIN_DIAGONAL_STRIPE: "thinDiagStripe",
+  THIN_HORIZONTAL_CROSS: "thinHorzCross",
+  THIN_REVERSE_DIAGONAL_STRIPE: "thinReverseDiagStripe",
+  THIN_VERTICAL_STRIPE: "thinVertStripe",
+  VERTICAL_STRIPE: "vertStripe"
+};
 var ChangeAttributes = class extends XmlAttributeComponent {
   constructor(..._args) {
     super(..._args);
@@ -110210,8 +110637,9 @@ function docxBlock(b, theme) {
             const isHeader = Boolean(b.header && i === 0);
             return new TableCell({
               width: { size: columnWidths[columnIndex] ?? 0, type: WidthType.DXA },
-              // Themed header row background (the visible "not cheap" cue).
-              ...isHeader ? { shading: { fill: bareHex(theme.colors.tableHeaderBg) } } : {},
+              // Themed header row background (the visible "not cheap" cue). w:shd
+              // requires w:val — a fill-only shading fails the strict XSD gate.
+              ...isHeader ? { shading: { type: ShadingType.CLEAR, color: "auto", fill: bareHex(theme.colors.tableHeaderBg) } } : {},
               children: [new Paragraph({ children: [new TextRun({ text: String(c), bold: isHeader })] })]
             });
           })
@@ -110424,6 +110852,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
@@ -110652,40 +111091,8 @@ async function validateOoxml(bytes) {
   return result(root.kind);
 }
 
-// packages/core/dist/document/pdf-extract.js
-var import_node_path = require("node:path");
-var import_node_url = require("node:url");
-var _mupdf = null;
-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;
-}
-async function openDoc(bytes) {
-  const mupdf = await loadMupdf();
-  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
-  if (doc.countPages() === 0) {
-    throw new Error("PDF has no readable pages (corrupt, encrypted, or empty)");
-  }
-  return { mupdf, doc };
-}
-async function renderPdfPages(bytes, pages, scale = 2) {
-  const { mupdf, doc } = await openDoc(bytes);
-  const total = doc.countPages();
-  const wanted = pages === "all" ? Array.from({ length: total }, (_2, i) => i + 1) : pages;
-  const out = [];
-  const matrix = mupdf.Matrix.scale(scale, scale);
-  for (const p of wanted) {
-    if (p < 1 || p > total)
-      continue;
-    const pix = doc.loadPage(p - 1).toPixmap(matrix, mupdf.ColorSpace.DeviceRGB, false, true);
-    out.push({ page: p, png: pix.asPNG() });
-  }
-  return out;
-}
+// apps/admin/data/skills.lib/document/bin-src/doc-gen.mjs
+init_pdf_extract();
 
 // packages/core/dist/document/html-escape.js
 function escapeHtml(value) {
@@ -110870,6 +111277,11 @@ async function fontManifest() {
   }
   return _fontManifest;
 }
+var _faceB64 = /* @__PURE__ */ new Map();
+async function faceBase64(path) {
+  if (!_faceB64.has(path)) _faceB64.set(path, (await (0, import_promises.readFile)(path).catch(() => null))?.toString("base64") ?? null);
+  return _faceB64.get(path);
+}
 async function faceCss(entries, range, doc) {
   const { dir } = await fontManifest();
   const rules = [];
@@ -110878,7 +111290,7 @@ async function faceCss(entries, range, doc) {
     if (!families.length) continue;
     const path = (0, import_node_path2.join)(dir, entry.file);
     if (!(0, import_node_fs.existsSync)(path)) continue;
-    const b64 = (await (0, import_promises.readFile)(path).catch(() => null))?.toString("base64");
+    const b64 = await faceBase64(path);
     if (!b64) continue;
     for (const family of families) {
       rules.push(
@@ -110888,22 +111300,21 @@ async function faceCss(entries, range, doc) {
   }
   return rules.join("");
 }
-var _cjkFontCss;
+var _faceCssBySet = /* @__PURE__ */ new Map();
+async function cachedFaceCss(group, entries, range, doc) {
+  const named = (entries ?? []).flatMap((e) => (e.families ?? []).filter((f) => doc.includes(f)));
+  const key = `${group}|${named.join("|")}`;
+  if (!_faceCssBySet.has(key)) _faceCssBySet.set(key, await faceCss(entries, range, doc));
+  return _faceCssBySet.get(key);
+}
 async function cjkFontFaceCss(doc) {
-  if (_cjkFontCss === void 0) {
-    const m = await fontManifest();
-    _cjkFontCss = await faceCss(m.cjk, m.cjkUnicodeRange, doc);
-  }
-  return _cjkFontCss;
+  if (process.env.TALOS_CJK_FONTS === "system") return "";
+  const m = await fontManifest();
+  return cachedFaceCss("cjk", m.cjk, m.cjkUnicodeRange, doc);
 }
-var _latinFontCss;
 async function latinFontFaceCss(doc) {
-  if (_latinFontCss === void 0) {
-    const m = await fontManifest();
-    const wanted = (m.latin ?? []).filter((e) => (e.families ?? []).some((f) => doc.includes(f)));
-    _latinFontCss = await faceCss(wanted, void 0);
-  }
-  return _latinFontCss;
+  const m = await fontManifest();
+  return cachedFaceCss("latin", m.latin, void 0, doc);
 }
 function injectStyle(html, css) {
   const tag = `<style>${css}</style>`;
@@ -110927,8 +111338,8 @@ async function renderPdfHeadless(html, print = {}) {
 }
 
 // apps/admin/data/skills.lib/document/bin-src/doc-gen.mjs
-var import_node_path3 = require("node:path");
-var import_node_fs2 = require("node:fs");
+var import_node_path4 = require("node:path");
+var import_node_fs3 = require("node:fs");
 var import_node_crypto = require("node:crypto");
 
 // packages/core/dist/document/doc-palette.js
@@ -111166,6 +111577,142 @@ function listPalettes() {
   return PALETTE_LIBRARY.map(({ name, mood, dark }) => ({ name, mood, dark }));
 }
 
+// packages/core/dist/document/deck-catalog.js
+var KINDS = ["skin", "pack"];
+var MODES = ["light", "dark"];
+var RENDER_MODES = ["classic-v1", "theme-v2"];
+var ID_RE = /^[a-z0-9][a-z0-9-]*$/;
+var COMMIT_RE = /^[0-9a-f]{7,40}$/;
+function isStr(v) {
+  return typeof v === "string" && v.length > 0;
+}
+function isStrArr(v) {
+  return Array.isArray(v) && v.every((x) => typeof x === "string");
+}
+function parseCatalog(raw) {
+  const errors = [];
+  const o = raw;
+  if (!o || typeof o !== "object")
+    return { catalog: null, errors: ["catalog is not an object"] };
+  const groups = [];
+  const rawGroups = Array.isArray(o.groups) ? o.groups : [];
+  if (!Array.isArray(o.groups))
+    errors.push("catalog.groups must be an array");
+  rawGroups.forEach((g, i) => {
+    const at = `group[${i}]`;
+    if (!isStr(g?.id) || !ID_RE.test(g.id))
+      errors.push(`${at}: bad id`);
+    if (!isStr(g?.name_cn))
+      errors.push(`${at}: missing name_cn`);
+    if (!isStr(g?.sample))
+      errors.push(`${at}: missing sample`);
+    if (!isStrArr(g?.scenarios))
+      errors.push(`${at}: scenarios must be a string array`);
+    if (isStr(g?.id) && isStr(g?.name_cn) && isStr(g?.sample) && isStrArr(g?.scenarios)) {
+      groups.push({ id: g.id, name_cn: g.name_cn, sample: g.sample, scenarios: g.scenarios });
+    }
+  });
+  const collections = [];
+  const rawCollections = o.collections === void 0 ? [] : Array.isArray(o.collections) ? o.collections : [];
+  if (o.collections !== void 0 && !Array.isArray(o.collections))
+    errors.push("catalog.collections must be an array when present");
+  rawCollections.forEach((c, i) => {
+    const at = `collection[${i}]`;
+    const before = errors.length;
+    if (!isStr(c?.id) || !ID_RE.test(c.id))
+      errors.push(`${at}: bad id`);
+    if (!isStr(c?.name_cn))
+      errors.push(`${at}: missing name_cn`);
+    if (!isStr(c?.renderMode) || !RENDER_MODES.includes(c.renderMode))
+      errors.push(`${at}: bad renderMode`);
+    if (!isStrArr(c?.entryIds) || c.entryIds.length === 0)
+      errors.push(`${at}: entryIds must be a non-empty string array`);
+    if (c?.sourceCommit !== void 0 && (!isStr(c.sourceCommit) || !COMMIT_RE.test(c.sourceCommit)))
+      errors.push(`${at}: bad sourceCommit`);
+    if (c?.renderMode === "classic-v1" && c?.sourceCommit === void 0)
+      errors.push(`${at}: classic-v1 requires sourceCommit`);
+    if (errors.length === before) {
+      collections.push({
+        id: c.id,
+        name_cn: c.name_cn,
+        renderMode: c.renderMode,
+        entryIds: c.entryIds,
+        ...c.sourceCommit !== void 0 ? { sourceCommit: c.sourceCommit } : {}
+      });
+    }
+  });
+  const entries = [];
+  const rawEntries = Array.isArray(o.entries) ? o.entries : [];
+  if (!Array.isArray(o.entries))
+    errors.push("catalog.entries must be an array");
+  rawEntries.forEach((e, i) => {
+    const at = `entry[${i}]${isStr(e?.id) ? ` (${e.id})` : ""}`;
+    const before = errors.length;
+    if (!isStr(e?.id) || !ID_RE.test(e.id))
+      errors.push(`${at}: bad id`);
+    if (!isStr(e?.kind) || !KINDS.includes(e.kind))
+      errors.push(`${at}: kind must be "skin" or "pack"`);
+    if (!isStr(e?.group))
+      errors.push(`${at}: missing group`);
+    if (!isStr(e?.name_cn))
+      errors.push(`${at}: missing name_cn`);
+    if (!isStr(e?.oneliner))
+      errors.push(`${at}: missing oneliner`);
+    if (!isStrArr(e?.scenarios))
+      errors.push(`${at}: scenarios must be a string array`);
+    if (!isStr(e?.mode) || !MODES.includes(e.mode))
+      errors.push(`${at}: mode must be "light" or "dark"`);
+    if (!isStr(e?.sample))
+      errors.push(`${at}: missing sample`);
+    if (e?.motion !== void 0 && !isStr(e.motion))
+      errors.push(`${at}: motion must be a string when present`);
+    if (errors.length === before) {
+      entries.push({
+        id: e.id,
+        kind: e.kind,
+        group: e.group,
+        name_cn: e.name_cn,
+        oneliner: e.oneliner,
+        scenarios: e.scenarios,
+        mode: e.mode,
+        sample: e.sample,
+        ...e.motion !== void 0 ? { motion: e.motion } : {}
+      });
+    }
+  });
+  return { catalog: errors.length ? null : { groups, ...collections.length ? { collections } : {}, entries }, errors };
+}
+function resolveEntry(catalog, id) {
+  return catalog.entries.find((e) => e.id === id) ?? null;
+}
+function assetDirOf(entry) {
+  return entry.kind === "skin" ? `styles/${entry.id}` : `packs/${entry.id}`;
+}
+function cssFileOf(entry) {
+  return entry.kind === "skin" ? "skin.css" : "pack.css";
+}
+
+// apps/admin/data/skills.lib/document/bin-src/lib/user-styles.mjs
+var import_node_fs2 = require("node:fs");
+var import_node_path3 = require("node:path");
+var SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+function userStylesDir() {
+  return process.env.TALOS_DOC_STYLES_DIR?.trim() || null;
+}
+function userSkinDir(name) {
+  const root = userStylesDir();
+  if (!root || !SAFE_NAME.test(name)) return null;
+  const dir = (0, import_node_path3.join)(root, "styles", name);
+  return (0, import_node_fs2.existsSync)((0, import_node_path3.join)(dir, "skin.css")) ? dir : null;
+}
+function userThemePath(name) {
+  const root = userStylesDir();
+  const base = name.replace(/\.json$/i, "");
+  if (!root || !SAFE_NAME.test(base)) return null;
+  const path = (0, import_node_path3.join)(root, "themes", `${base}.json`);
+  return (0, import_node_fs2.existsSync)(path) ? path : null;
+}
+
 // apps/admin/data/skills.lib/document/bin-src/doc-gen.mjs
 function die(msg, code = 1) {
   process.stderr.write(`doc-gen: ${msg}
@@ -111173,7 +111720,7 @@ function die(msg, code = 1) {
   process.exit(code);
 }
 async function writeArtifactAtomically(out, bytes) {
-  const temp = (0, import_node_path3.join)((0, import_node_path3.dirname)(out), `.${(0, import_node_path3.basename)(out)}.${process.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`);
+  const temp = (0, import_node_path4.join)((0, import_node_path4.dirname)(out), `.${(0, import_node_path4.basename)(out)}.${process.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`);
   try {
     await (0, import_promises2.writeFile)(temp, Buffer.from(bytes), { flag: "wx" });
     await (0, import_promises2.rename)(temp, out);
@@ -111237,6 +111784,7 @@ async function main() {
     themePath = args[themeIdx + 1];
     if (!themePath) die("--theme needs a path to a theme.json", 64);
     args.splice(themeIdx, 2);
+    if (!(0, import_node_fs3.existsSync)(themePath)) themePath = userThemePath(themePath) ?? themePath;
   }
   const topicFlag = takeFlag(args, "--topic");
   const paletteFlag = takeFlag(args, "--palette");
@@ -111272,9 +111820,18 @@ async function main() {
   } else if (accentFlag || styleFlag) {
     let accent = accentFlag;
     if (!accent && styleFlag) {
-      const skillDir = (0, import_node_path3.dirname)((0, import_node_path3.dirname)(process.argv[1] || ""));
-      const styleDir = (0, import_node_fs2.existsSync)((0, import_node_path3.join)(styleFlag, "skin.css")) ? styleFlag : (0, import_node_path3.join)(skillDir, "styles", styleFlag);
-      const skinPath = (0, import_node_path3.join)(styleDir, "skin.css");
+      const skillDir = (0, import_node_path4.dirname)((0, import_node_path4.dirname)(process.argv[1] || ""));
+      let skinPath = (0, import_node_path4.join)(styleFlag, "skin.css");
+      if (!(0, import_node_fs3.existsSync)(skinPath)) {
+        const user = userSkinDir(styleFlag);
+        skinPath = user ? (0, import_node_path4.join)(user, "skin.css") : (0, import_node_path4.join)(skillDir, "styles", styleFlag, "skin.css");
+        try {
+          const { catalog } = parseCatalog(JSON.parse(await (0, import_promises2.readFile)((0, import_node_path4.join)(skillDir, "catalog.json"), "utf-8")));
+          const entry = catalog ? resolveEntry(catalog, styleFlag) : null;
+          if (entry) skinPath = (0, import_node_path4.join)(skillDir, assetDirOf(entry), cssFileOf(entry));
+        } catch {
+        }
+      }
       let skinCss;
       try {
         skinCss = await (0, import_promises2.readFile)(skinPath, "utf-8");
@@ -111282,7 +111839,7 @@ async function main() {
         die(`--style: cannot read ${skinPath}`, 66);
       }
       accent = skinAccentColor(skinCss);
-      if (!accent) die(`--style ${styleFlag}: no hex --accent in skin.css`, 65);
+      if (!accent) die(`--style ${styleFlag}: no hex --accent in ${skinPath}`, 65);
     }
     rawTheme = accentOnlyTheme(accent);
     if (!rawTheme.colors) process.stderr.write(`doc-gen: --accent ${accent}: not a #rrggbb hex; using plain black-on-white
@@ -111333,7 +111890,7 @@ async function reportPdf(out, bytes, spec, noPreview) {
   if (!noPreview && validation.ok) {
     try {
       for (const r of await renderPdfPages(bytes, "all", 1)) {
-        const dest = (0, import_node_path3.join)((0, import_node_path3.dirname)(out), `${(0, import_node_path3.basename)(out).replace(/\.[^.]+$/, "")}_p${r.page}.png`);
+        const dest = (0, import_node_path4.join)((0, import_node_path4.dirname)(out), `${(0, import_node_path4.basename)(out).replace(/\.[^.]+$/, "")}_p${r.page}.png`);
         await (0, import_promises2.writeFile)(dest, Buffer.from(r.png));
         previews.push(dest);
       }