@taloswork/ose-shared 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taloswork/ose-shared",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Talos cross-OSE shared library — skills + MCP servers auto-loaded into every OSE (P93 2026-07-27).",
   "type": "module",
   "files": [
@@ -10,6 +10,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "_talosPublishHash": "sha256-_TBER93S6Gcnoc6VaJyOr1oERYK8cA1G_ifT0tdC3ZQ",
-  "_talosPublishedAt": "2026-08-27T14:52:48.964Z"
+  "_talosPublishHash": "sha256-T36gm46DynkzOQOg4I0N8sK_-SP1h0kOm1929zOwv9U",
+  "_talosPublishedAt": "2026-09-02T17:54:52.828Z"
 }

package/skills/document/SKILL.md

@@ -200,7 +200,7 @@ Fidelity-decision self-correct, but pointed at your OWN output:
 - `bin/pdf-tables.cjs <file.pdf> [page] [minCols]` — recover text-layer tables as rows (ruled/scanned tables need render + vision instead).
 - `bin/ocr.cjs <image.png|jpg> [lang]` — read text off a scanned image (tesseract.js). For a scanned PDF, `pdf-render` a page first, then OCR the PNG. Language data downloads on first use / set `$TALOS_TESSDATA` for offline. **Prefer vision** when a vision model is available; OCR is the text-only fallback.
 - `bin/xlsx-query.cjs <file> [--summary | --agg <sheet> <col> <op> | --sample <sheet> [n]]` — spreadsheet compute.
-- `bin/doc-gen.cjs <docx|xlsx|pptx|pdf> <out> <spec.json> [--theme <theme.json>] [--topic <subject> | --palette <id>] [--design native|html]` — generate documents from scratch; `--theme` applies a presentation theme (colors/fonts/cover/header/footer/pptx master — see rewrite.md "Themes"; built-ins in `themes/`). **`--topic <subject>` (pptx, when no `--theme`) picks a topic-adaptive palette** so the deck is designed-for-subject instead of template-flat, and turns on richness (motif + gradient wash + depth). `--palette <id>` forces a specific palette (`doc-gen --list-palettes` prints them). **`--accent <#hex>` / `--style <skin>` (docx/pdf)**: white-paper-black-text base with ONE brand color on H1/H2 + a faint table-header tint — the practical doc shape (a document is read/printed/edited, not projected, so body text stays near-black). `--accent` takes a literal hex; `--style <skin>` pulls just the `--accent` from `styles/<skin>/skin.css` (the deck skin's full palette is NOT carried onto paper). Precedence: `--theme` > spec `"theme"` > `--accent`/`--style` > `--palette`/`--topic` > default. `--design html` (pptx only, in-app) renders eligible slides through designed HTML templates for a magazine look — richer but a flat collage (no master structure); auto-falls back to native when headless or a slide has no template. Default `native` (structured, editable, charts, headless-safe).
+- `bin/doc-gen.cjs <docx|xlsx|pptx|pdf> <out> <spec.json> [--theme <theme.json>] [--topic <subject> | --palette <id>] [--design native|html]` — generate documents from scratch. DOCX/PDF body fields are exactly `paragraphs` and/or `blocks` (never `sections`); unknown fields and empty bodies fail with `DOC_SPEC_INVALID` before any output is written (`allowCoverOnly:true` is the explicit title-only opt-in). Correct the reported JSON path and rerun. `--theme` applies a presentation theme (colors/fonts/cover/header/footer/pptx master — see rewrite.md "Themes"; built-ins in `themes/`). **`--topic <subject>` (pptx, when no `--theme`) picks a topic-adaptive palette** so the deck is designed-for-subject instead of template-flat, and turns on richness (motif + gradient wash + depth). `--palette <id>` forces a specific palette (`doc-gen --list-palettes` prints them). **`--accent <#hex>` / `--style <skin>` (docx/pdf)**: white-paper-black-text base with ONE brand color on H1/H2 + a faint table-header tint — the practical doc shape (a document is read/printed/edited, not projected, so body text stays near-black). `--accent` takes a literal hex; `--style <skin>` pulls just the `--accent` from `styles/<skin>/skin.css` (the deck skin's full palette is NOT carried onto paper). Precedence: `--theme` > spec `"theme"` > `--accent`/`--style` > `--palette`/`--topic` > default. `--design html` (pptx only, in-app) renders eligible slides through designed HTML templates for a magazine look — richer but a flat collage (no master structure); auto-falls back to native when headless or a slide has no template. Default `native` (structured, editable, charts, headless-safe).
 - `bin/doc-convert.cjs <in.docx|pptx|xlsx> <out.pdf>` — faithful docx/pptx/xlsx → PDF conversion. Engine precedence (best fidelity first, each downgrade tagged on stdout `[pdf (…)]` + warned on stderr): (1) **LibreOffice** if a system `soffice` is found — true layout render (page geometry, headers/footers, text-box positions, native charts), offline; (2) **LibreOffice sidecar** if `TALOS_OFFICE_URL` is set — same true-layout fidelity via a remote converter (e.g. Gotenberg), needs network; (3) **Chromium** (in-app) — reconstructed HTML, content/structure/images preserved but in-document layout is not (pptx = one page per slide); (4) **pdf-lib text-only** headless last resort — images/tables flatten. Surface the resulting `[pdf (engine)]` caveat to the user. NOTE: spreadsheets (xlsx/xls/ods) render ONLY via tiers 1–2 (real LibreOffice); tiers 3–4 do not rebuild spreadsheets, so with no LibreOffice available the command errors (never a degraded text-only sheet).
 - `bin/doc-validate.cjs <file.docx|pptx|xlsx> [--strict] [--design-lint]` — structural OOXML validation gate (zip/parts/rels/Content_Types/XML well-formedness); run after every generation or edit; exit 1 = broken, fix before delivering. `--strict` adds full ECMA-376 schema (XSD) validation of every recognised part — REQUIRED after custom-code (doc-run/html2pptx) or raw-XML output; a strict failure means the file is non-standard even if Office opens it. `--design-lint` (pptx only) adds an ADVISORY design pass — flags `text-only-slide` (a wall of text with no visual anchor), `low-contrast-text`, `placeholder-text` (a layout pasted but never filled — 替换为…/占位/Lorem still in the slide), `font-mismatch` (CJK text set in a Latin-only font → 豆腐; expected language defaults to the system locale, override with `TALOS_DECK_LANG`), `off-canvas`, `tiny-font`, `shape-overlap`; findings are warnings (never change the exit code) but are real design bugs — fix them. See deck-design.md "Design principles".
 - `bin/deck-qa.cjs <file.pptx> [--json]` — MECHANICAL design QA (deterministic, token-free): reads slide XML and flags `off-canvas` (content clipped past the edge), `tiny-font` (<10pt), `shape-overlap` (colliding text), plus `text-only-slide` / `low-contrast-text` / `placeholder-text` / `font-mismatch` (CJK text in a Latin-only font → 豆腐). Advisory (exit 0 even with findings). `--json` → `{ok,findings:[{slide,code,message}]}` for the visual-QA loop. It is the CHEAP GATE before spending vision tokens — run it every QA round and fix all findings first; then do the vision critic + per-slide regeneration (deck-design.md "Verify before delivering").

package/skills/document/bin/deck-build.cjs

@@ -6,7 +6,7 @@ var import_promises = require("node:fs/promises");
 var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
 
-// packages/core/dist/fs/deck-figures.js
+// packages/core/dist/document/deck-figures.js
 var FIGURE_SPECS = {
   radar: {
     metrics: { required: ["name", "score"], derived: [] }
@@ -159,7 +159,7 @@ function derivePins(rows, warnings) {
   });
 }
 
-// packages/core/dist/fs/deck-build.js
+// packages/core/dist/document/deck-build.js
 var SLOT_RE = /\{\{(?![#/])([^{}]*)\}\}/g;
 var BLOCK_RE = /\{\{#([A-Za-z_][\w-]*)\}\}([\s\S]*?)\{\{\/\1\}\}/g;
 function escapeHtml(s) {

package/skills/document/bin/deck-qa.cjs

@@ -9818,7 +9818,7 @@ var require_lib3 = __commonJS({
 // apps/admin/data/skills.lib/document/bin-src/deck-qa.mjs
 var import_promises = require("node:fs/promises");
 
-// packages/core/dist/fs/doc-design-lint.js
+// packages/core/dist/document/doc-design-lint.js
 var import_jszip = __toESM(require_lib3(), 1);
 var PLACEHOLDER_RE = /替换为|在这里写|占位|示例文本|Lorem ipsum/i;
 var CJK_TEXT_RE = /[぀-ヿ㐀-䶿一-鿿가-힯豈-﫿]/;

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

@@ -148976,11 +148976,11 @@ var require_fontkit_umd = __commonJS({
 var import_node_path2 = require("node:path");
 var import_promises2 = require("node:fs/promises");
 
-// packages/core/dist/fs/doc-convert.js
+// packages/core/dist/document/doc-convert.js
 var import_jszip3 = __toESM(require_lib3(), 1);
 var import_mammoth2 = __toESM(require_lib6(), 1);
 
-// packages/core/dist/fs/office-converter.js
+// packages/core/dist/document/office-converter.js
 var import_jszip = __toESM(require_lib3(), 1);
 var import_mammoth = __toESM(require_lib6(), 1);
 function isZipMagic(buffer) {
@@ -168101,7 +168101,7 @@ var findPatchKeys = (text) => {
   return (_text$match = text.match(pattern)) !== null && _text$match !== void 0 ? _text$match : [];
 };
 
-// packages/core/dist/fs/doc-gen.js
+// packages/core/dist/document/doc-gen.js
 var import_exceljs = __toESM(require_excel(), 1);
 var import_jszip2 = __toESM(require_lib3(), 1);
 var import_pptxgenjs = __toESM(require_pptxgen_cjs(), 1);
@@ -168109,7 +168109,7 @@ var import_pdf_lib = __toESM(require_cjs(), 1);
 var import_fontkit = __toESM(require_fontkit_umd(), 1);
 var import_node_fs = require("node:fs");
 
-// packages/core/dist/fs/doc-theme.js
+// packages/core/dist/document/doc-theme.js
 var DEFAULT_THEME = {
   bestFor: "",
   fonts: { heading: "", body: "" },
@@ -168301,7 +168301,7 @@ function asTheme(themeInput) {
   return themeInput && typeof themeInput === "object" && "warnings" in themeInput ? themeInput : resolveTheme(themeInput);
 }
 
-// packages/core/dist/fs/doc-palette.js
+// packages/core/dist/document/doc-palette.js
 var PALETTE_LIBRARY = [
   {
     name: "corporate-navy",
@@ -168536,7 +168536,7 @@ function themeSpecFromTopic(topic) {
   return paletteToThemeSpec(resolvePalette(topic));
 }
 
-// packages/core/dist/fs/lucide-icons.js
+// packages/core/dist/document/lucide-icons.js
 var LUCIDE_ICONS = {
   check: '<path d="M20 6 9 17l-5-5"/>',
   "check-circle": '<circle cx="12" cy="12" r="10"/><path d="m9 12 2 2 4-4"/>',
@@ -168593,16 +168593,289 @@ function iconSvgDataUri(name, colorHex) {
   return "data:image/svg+xml;base64," + Buffer.from(svg).toString("base64");
 }
 
-// packages/core/dist/fs/doc-gen.js
+// packages/core/dist/document/doc-gen.js
 function bareHex(c) {
   return c.replace("#", "").toUpperCase();
 }
+var DocumentSpecValidationError = class extends Error {
+  code = "DOC_SPEC_INVALID";
+  issues;
+  constructor(issues) {
+    const detail = issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ");
+    super(`DOC_SPEC_INVALID: ${detail}`);
+    this.name = "DocumentSpecValidationError";
+    this.issues = [...issues];
+  }
+};
+var TEXT_DOCUMENT_KEYS = /* @__PURE__ */ new Set(["title", "paragraphs", "blocks", "allowCoverOnly", "fontPath", "theme", "topic", "palette"]);
+var XLSX_DOCUMENT_KEYS = /* @__PURE__ */ new Set(["sheets", "theme", "topic", "palette"]);
+var PPTX_DOCUMENT_KEYS = /* @__PURE__ */ new Set(["slides", "theme", "topic", "palette"]);
+var PPTX_SLIDE_KEYS = /* @__PURE__ */ new Set([
+  "title",
+  "cover",
+  "toc",
+  "ending",
+  "section",
+  "kpiCards",
+  "cards",
+  "timeline",
+  "steps",
+  "iconList",
+  "splitImage",
+  "comparison",
+  "quadrant",
+  "bigStat",
+  "quote",
+  "bullets",
+  "table",
+  "image",
+  "chart"
+]);
+function isJsonRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function addUnknownPropertyIssues(record, allowed, path, issues) {
+  for (const key of Object.keys(record)) {
+    if (allowed.has(key))
+      continue;
+    const message = allowed === TEXT_DOCUMENT_KEYS && (key === "section" || key === "sections") ? `${key} is unsupported for DOCX/PDF content; use $.blocks with heading/paragraph/list/table/image blocks (section is PPTX-only)` : `unsupported property ${JSON.stringify(key)}; allowed properties: ${[...allowed].join(", ")}`;
+    issues.push({ path: `${path}.${key}`, code: "UNKNOWN_PROPERTY", message });
+  }
+}
+function nonBlankString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function validateTextBlock(value, path, issues) {
+  if (!isJsonRecord(value)) {
+    issues.push({ path, code: "INVALID_TYPE", message: "block must be an object" });
+    return false;
+  }
+  if (typeof value.type !== "string") {
+    issues.push({ path: `${path}.type`, code: "INVALID_TYPE", message: "block type must be a string" });
+    return false;
+  }
+  const requireText = () => {
+    if (nonBlankString(value.text))
+      return true;
+    issues.push({ path: `${path}.text`, code: "EMPTY_CONTENT", message: "text must be a non-empty string" });
+    return false;
+  };
+  switch (value.type) {
+    case "heading": {
+      addUnknownPropertyIssues(value, /* @__PURE__ */ new Set(["type", "text", "level"]), path, issues);
+      const valid = requireText();
+      if (value.level !== void 0 && ![1, 2, 3, 4].includes(value.level)) {
+        issues.push({ path: `${path}.level`, code: "INVALID_VALUE", message: "level must be one of 1, 2, 3, 4" });
+      }
+      return valid;
+    }
+    case "paragraph": {
+      addUnknownPropertyIssues(value, /* @__PURE__ */ new Set(["type", "text", "bold", "italic"]), path, issues);
+      const valid = requireText();
+      for (const key of ["bold", "italic"]) {
+        if (value[key] !== void 0 && typeof value[key] !== "boolean") {
+          issues.push({ path: `${path}.${key}`, code: "INVALID_TYPE", message: `${key} must be a boolean` });
+        }
+      }
+      return valid;
+    }
+    case "list": {
+      addUnknownPropertyIssues(value, /* @__PURE__ */ new Set(["type", "items", "ordered"]), path, issues);
+      if (!Array.isArray(value.items) || value.items.length === 0) {
+        issues.push({ path: `${path}.items`, code: "EMPTY_CONTENT", message: "items must be a non-empty string array" });
+        return false;
+      }
+      let valid = true;
+      value.items.forEach((item, index) => {
+        if (nonBlankString(item))
+          return;
+        valid = false;
+        issues.push({ path: `${path}.items[${index}]`, code: "EMPTY_CONTENT", message: "list item must be a non-empty string" });
+      });
+      if (value.ordered !== void 0 && typeof value.ordered !== "boolean") {
+        issues.push({ path: `${path}.ordered`, code: "INVALID_TYPE", message: "ordered must be a boolean" });
+      }
+      return valid;
+    }
+    case "table": {
+      addUnknownPropertyIssues(value, /* @__PURE__ */ new Set(["type", "rows", "header", "columnWidths"]), path, issues);
+      if (!Array.isArray(value.rows) || value.rows.length === 0) {
+        issues.push({ path: `${path}.rows`, code: "EMPTY_CONTENT", message: "rows must be a non-empty array" });
+        return false;
+      }
+      let hasCellContent = false;
+      value.rows.forEach((row, rowIndex) => {
+        if (!Array.isArray(row) || row.length === 0) {
+          issues.push({ path: `${path}.rows[${rowIndex}]`, code: "INVALID_TYPE", message: "table row must be a non-empty array" });
+          return;
+        }
+        row.forEach((cell, columnIndex) => {
+          if (typeof cell !== "string" && typeof cell !== "number") {
+            issues.push({ path: `${path}.rows[${rowIndex}][${columnIndex}]`, code: "INVALID_TYPE", message: "table cell must be a string or number" });
+          } else if (String(cell).trim().length > 0) {
+            hasCellContent = true;
+          }
+        });
+      });
+      if (!hasCellContent) {
+        issues.push({ path: `${path}.rows`, code: "EMPTY_CONTENT", message: "table must contain at least one non-empty cell" });
+      }
+      if (value.header !== void 0 && typeof value.header !== "boolean") {
+        issues.push({ path: `${path}.header`, code: "INVALID_TYPE", message: "header must be a boolean" });
+      }
+      if (value.columnWidths !== void 0 && (!Array.isArray(value.columnWidths) || value.columnWidths.some((width) => typeof width !== "number" || !Number.isFinite(width) || width <= 0))) {
+        issues.push({ path: `${path}.columnWidths`, code: "INVALID_VALUE", message: "columnWidths must contain only positive finite numbers" });
+      }
+      return hasCellContent;
+    }
+    case "image": {
+      addUnknownPropertyIssues(value, /* @__PURE__ */ new Set(["type", "data", "imageType", "width", "height"]), path, issues);
+      if (!nonBlankString(value.data)) {
+        issues.push({ path: `${path}.data`, code: "EMPTY_CONTENT", message: "image data must be non-empty base64" });
+        return false;
+      }
+      if (value.imageType !== void 0 && !["png", "jpg", "gif", "bmp"].includes(String(value.imageType))) {
+        issues.push({ path: `${path}.imageType`, code: "INVALID_VALUE", message: "imageType must be png, jpg, gif, or bmp" });
+      }
+      for (const key of ["width", "height"]) {
+        if (value[key] !== void 0 && (typeof value[key] !== "number" || !Number.isFinite(value[key]) || value[key] <= 0)) {
+          issues.push({ path: `${path}.${key}`, code: "INVALID_VALUE", message: `${key} must be a positive finite number` });
+        }
+      }
+      return true;
+    }
+    default:
+      issues.push({ path: `${path}.type`, code: "INVALID_VALUE", message: `unhandled block type: ${value.type}` });
+      return false;
+  }
+}
+function inspectTextDocumentSpec(spec) {
+  const issues = [];
+  if (!isJsonRecord(spec)) {
+    issues.push({ path: "$", code: "INVALID_TYPE", message: "spec must be a JSON object" });
+    return { issues, hasBody: false, hasTitle: false, allowCoverOnly: false };
+  }
+  addUnknownPropertyIssues(spec, TEXT_DOCUMENT_KEYS, "$", issues);
+  const hasTitle = nonBlankString(spec.title);
+  if (spec.title !== void 0 && !hasTitle) {
+    issues.push({ path: "$.title", code: "EMPTY_CONTENT", message: "title must be a non-empty string when provided" });
+  }
+  if (spec.allowCoverOnly !== void 0 && typeof spec.allowCoverOnly !== "boolean") {
+    issues.push({ path: "$.allowCoverOnly", code: "INVALID_TYPE", message: "allowCoverOnly must be a boolean" });
+  }
+  if (spec.fontPath !== void 0 && !nonBlankString(spec.fontPath)) {
+    issues.push({ path: "$.fontPath", code: "INVALID_TYPE", message: "fontPath must be a non-empty string" });
+  }
+  let hasBody = false;
+  if (spec.paragraphs !== void 0) {
+    if (!Array.isArray(spec.paragraphs)) {
+      issues.push({ path: "$.paragraphs", code: "INVALID_TYPE", message: "paragraphs must be a string array" });
+    } else {
+      spec.paragraphs.forEach((paragraph, index) => {
+        if (nonBlankString(paragraph))
+          hasBody = true;
+        else
+          issues.push({ path: `$.paragraphs[${index}]`, code: "EMPTY_CONTENT", message: "paragraph must be a non-empty string" });
+      });
+    }
+  }
+  if (spec.blocks !== void 0) {
+    if (!Array.isArray(spec.blocks)) {
+      issues.push({ path: "$.blocks", code: "INVALID_TYPE", message: "blocks must be an array" });
+    } else {
+      spec.blocks.forEach((block, index) => {
+        if (validateTextBlock(block, `$.blocks[${index}]`, issues))
+          hasBody = true;
+      });
+    }
+  }
+  return { issues, hasBody, hasTitle, allowCoverOnly: spec.allowCoverOnly === true };
+}
 function assertTextDocumentSpec(spec) {
-  if (!spec || typeof spec !== "object")
+  const { issues } = inspectTextDocumentSpec(spec);
+  if (issues.length > 0)
+    throw new DocumentSpecValidationError(issues);
+}
+function validateRows(rows, path, issues) {
+  if (!Array.isArray(rows) || rows.length === 0) {
+    issues.push({ path, code: "EMPTY_CONTENT", message: "rows must be a non-empty array" });
+    return false;
+  }
+  let hasContent = false;
+  rows.forEach((row, rowIndex) => {
+    if (!Array.isArray(row) || row.length === 0) {
+      issues.push({ path: `${path}[${rowIndex}]`, code: "INVALID_TYPE", message: "row must be a non-empty array" });
+      return;
+    }
+    row.forEach((cell, columnIndex) => {
+      if (typeof cell !== "string" && typeof cell !== "number") {
+        issues.push({ path: `${path}[${rowIndex}][${columnIndex}]`, code: "INVALID_TYPE", message: "cell must be a string or number" });
+      } else if (String(cell).trim().length > 0) {
+        hasContent = true;
+      }
+    });
+  });
+  if (!hasContent)
+    issues.push({ path, code: "EMPTY_CONTENT", message: "rows must contain at least one non-empty cell" });
+  return hasContent;
+}
+function assertDocumentSpec(kind, spec) {
+  if (kind === "docx" || kind === "pdf") {
+    const inspection = inspectTextDocumentSpec(spec);
+    if (!inspection.hasBody && !(inspection.allowCoverOnly && inspection.hasTitle)) {
+      inspection.issues.push({
+        path: "$",
+        code: "EMPTY_CONTENT",
+        message: "document body is empty; provide non-empty paragraphs/blocks, or set allowCoverOnly=true with a non-empty title"
+      });
+    }
+    if (inspection.issues.length > 0)
+      throw new DocumentSpecValidationError(inspection.issues);
     return;
-  if (Object.prototype.hasOwnProperty.call(spec, "section")) {
-    throw new Error("unsupported document field: section (use blocks for DOCX/PDF content; section is PPTX-only)");
   }
+  const issues = [];
+  if (!isJsonRecord(spec)) {
+    throw new DocumentSpecValidationError([{ path: "$", code: "INVALID_TYPE", message: "spec must be a JSON object" }]);
+  }
+  if (kind === "xlsx") {
+    addUnknownPropertyIssues(spec, XLSX_DOCUMENT_KEYS, "$", issues);
+    if (!isJsonRecord(spec.sheets) || Object.keys(spec.sheets).length === 0) {
+      issues.push({ path: "$.sheets", code: "EMPTY_CONTENT", message: "sheets must be a non-empty object" });
+    } else {
+      for (const [name, sheet] of Object.entries(spec.sheets)) {
+        const path = `$.sheets[${JSON.stringify(name)}]`;
+        if (Array.isArray(sheet)) {
+          validateRows(sheet, path, issues);
+        } else if (isJsonRecord(sheet)) {
+          addUnknownPropertyIssues(sheet, /* @__PURE__ */ new Set(["rows", "header", "columnWidths", "numFmt"]), path, issues);
+          validateRows(sheet.rows, `${path}.rows`, issues);
+        } else {
+          issues.push({ path, code: "INVALID_TYPE", message: "sheet must be a row array or an object containing rows" });
+        }
+      }
+    }
+  } else if (kind === "pptx") {
+    addUnknownPropertyIssues(spec, PPTX_DOCUMENT_KEYS, "$", issues);
+    if (!Array.isArray(spec.slides) || spec.slides.length === 0) {
+      issues.push({ path: "$.slides", code: "EMPTY_CONTENT", message: "slides must be a non-empty array" });
+    } else {
+      spec.slides.forEach((slide, index) => {
+        const path = `$.slides[${index}]`;
+        if (!isJsonRecord(slide)) {
+          issues.push({ path, code: "INVALID_TYPE", message: "slide must be an object" });
+          return;
+        }
+        addUnknownPropertyIssues(slide, PPTX_SLIDE_KEYS, path, issues);
+        if (Object.keys(slide).length === 0) {
+          issues.push({ path, code: "EMPTY_CONTENT", message: "slide must contain at least one supported field" });
+        }
+      });
+    }
+  } else {
+    throw new Error(`unsupported kind: ${String(kind)}`);
+  }
+  if (issues.length > 0)
+    throw new DocumentSpecValidationError(issues);
 }
 var HEADINGS = [HeadingLevel.HEADING_1, HeadingLevel.HEADING_2, HeadingLevel.HEADING_3, HeadingLevel.HEADING_4];
 var ORDERED_REF = "ol";
@@ -169864,6 +170137,7 @@ async function generatePdf(spec, themeInput) {
   return doc.save();
 }
 async function generateDocument(kind, spec, theme) {
+  assertDocumentSpec(kind, spec);
   switch (kind) {
     case "docx":
       return generateDocx(spec, theme);
@@ -169878,10 +170152,10 @@ async function generateDocument(kind, spec, theme) {
   }
 }
 
-// packages/core/dist/fs/doc-html.js
+// packages/core/dist/document/doc-html.js
 var FONT_STACK = 'TalosCJK, "Helvetica Neue", Helvetica, Arial, "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", "Noto Sans CJK SC", "Source Han Sans SC", "WenQuanYi Zen Hei", sans-serif';
 
-// packages/core/dist/fs/doc-convert.js
+// packages/core/dist/document/doc-convert.js
 var PRINT_STYLE = `
 @page { size: A4; margin: 20mm 18mm; }
 * { box-sizing: border-box; }
@@ -169992,7 +170266,7 @@ async function convertOfficeToPrintable(buffer, filename) {
   return { error: `\u4E0D\u652F\u6301 ${filename} \u7684\u6587\u4EF6\u683C\u5F0F\uFF08doc-convert \u53EA\u652F\u6301 .docx/.pptx\uFF09` };
 }
 
-// packages/core/dist/fs/soffice.js
+// packages/core/dist/document/soffice.js
 var import_node_child_process = require("node:child_process");
 var import_node_fs2 = require("node:fs");
 var import_promises = require("node:fs/promises");
@@ -170138,7 +170412,7 @@ function runSoffice(bin, args, timeoutMs) {
   });
 }
 
-// packages/core/dist/fs/office-service.js
+// packages/core/dist/document/office-service.js
 async function convertViaOfficeService(bytes, filename, url, options = {}) {
   const doFetch = options.fetchImpl ?? fetch;
   const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);

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

@@ -16068,7 +16068,7 @@ var require_js = __commonJS({
 var import_promises = require("node:fs/promises");
 var import_node_path = require("node:path");
 
-// packages/core/dist/fs/doc-template.js
+// packages/core/dist/document/doc-template.js
 var import_docxtemplater = __toESM(require_docxtemplater(), 1);
 var import_pizzip = __toESM(require_js(), 1);
 var DEFAULT_DELIMITERS = { start: "{{", end: "}}" };