@taloswork/ose-shared 0.1.11 → 0.1.12

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

@@ -0,0 +1,802 @@
+#!/usr/bin/env node
+"use strict";
+
+// apps/admin/data/skills.lib/document/bin-src/deck-plan.mjs
+var import_promises = require("node:fs/promises");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+
+// packages/core/dist/document/deck-figures.js
+var FIGURE_SPECS = {
+  radar: {
+    metrics: { required: ["name", "score"], derived: [] }
+  },
+  gantt: {
+    cols: { required: ["label"], derived: [] },
+    tasks: { required: ["name", "from", "to"], derived: ["_left", "_width"] }
+  },
+  "ring-progress": {
+    rings: { required: ["label", "pct"], derived: ["_pct", "_dashoffset"] }
+  },
+  "map-distribution": {
+    regions: { required: ["name", "pct"], derived: [] },
+    pins: { required: ["x", "y"], derived: ["_left", "_top"] }
+  }
+};
+var DERIVED_CHART_LAYOUTS = /* @__PURE__ */ new Set(["radar"]);
+var DERIVED_CHART_OPTIONS = /* @__PURE__ */ new Set(["max", "unit", "showValues", "render"]);
+function rowsFromChart(layout, chart) {
+  if (!DERIVED_CHART_LAYOUTS.has(layout))
+    return { reject: `${layout} does not derive its chart from rows` };
+  const c = chart && typeof chart === "object" && !Array.isArray(chart) ? chart : null;
+  if (!c || c.type !== "radar")
+    return { reject: `draws only a radar chart (content chart type: ${String(c?.type ?? "none")})` };
+  const labels = Array.isArray(c.labels) ? c.labels : [];
+  const series = Array.isArray(c.series) ? c.series : [];
+  if (series.length !== 1)
+    return { reject: `its score list holds one series \u2014 the radar has ${series.length}` };
+  const values = series[0]?.values;
+  if (!labels.length || !Array.isArray(values) || values.length !== labels.length) {
+    return { reject: `needs one value per radar dimension (${labels.length} label(s), ${Array.isArray(values) ? values.length : 0} value(s))` };
+  }
+  const options = {};
+  for (const [k, v] of Object.entries(c))
+    if (DERIVED_CHART_OPTIONS.has(k))
+      options[k] = v;
+  return { rows: { metrics: labels.map((name, j) => ({ name: String(name), score: values[j] })) }, options };
+}
+
+// packages/core/dist/document/deck-chart-svg.js
+var RAMP = [
+  "var(--series-1, var(--c1, var(--accent)))",
+  "var(--series-2, var(--c2, var(--muted)))",
+  "var(--series-3, var(--c3, var(--title)))",
+  "var(--series-4, var(--c4, var(--body)))"
+];
+var MAX_SERIES = RAMP.length;
+
+// packages/core/dist/document/deck-build.js
+var SLOT_RE = /\{\{(?![#/])([^{}]*)\}\}/g;
+var BLOCK_RE = /\{\{#([A-Za-z_][\w-]*)\}\}([\s\S]*?)\{\{\/\1\}\}/g;
+var slotName = (inner) => {
+  const bar = inner.indexOf("|");
+  return (bar >= 0 ? inner.slice(0, bar) : inner).trim();
+};
+var withoutComments = (tpl) => tpl.replace(/<!--[\s\S]*?-->/g, "");
+var withoutBlocks = (tpl) => tpl.replace(BLOCK_RE, "");
+function templateDefaults(tpl) {
+  const out = {};
+  for (const m of withoutBlocks(withoutComments(tpl)).matchAll(SLOT_RE)) {
+    const name = slotName(m[1]);
+    if (name.startsWith("_") || Object.hasOwn(out, name))
+      continue;
+    const bar = m[1].indexOf("|");
+    out[name] = bar >= 0 ? m[1].slice(bar + 1) : "";
+  }
+  return out;
+}
+
+// packages/core/dist/document/ooxml-util.js
+function visualWidth(text) {
+  let w = 0;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    if (ch === " " || ch === "	")
+      w += 0.35;
+    else if (cp >= 4352 && cp <= 4447 || // Hangul Jamo
+    cp >= 11904 && cp <= 40959 || // CJK radicals … unified ideographs
+    cp >= 40960 && cp <= 42191 || // Yi
+    cp >= 44032 && cp <= 55203 || // Hangul syllables
+    cp >= 63744 && cp <= 64255 || // CJK compat ideographs
+    cp >= 65072 && cp <= 65103 || // CJK compat forms
+    cp >= 65280 && cp <= 65376 || // fullwidth forms
+    cp >= 65504 && cp <= 65510 || cp >= 131072 && cp <= 262141)
+      w += 1;
+    else
+      w += 0.5;
+  }
+  return w;
+}
+
+// packages/core/dist/document/deck-capacity.js
+function parseCapacityDoc(raw) {
+  const d = raw;
+  if (!d || typeof d !== "object" || !Array.isArray(d.styles) || !d.layouts || typeof d.layouts !== "object")
+    return null;
+  return d;
+}
+function pick(v, idx, ceiling) {
+  if (v === void 0)
+    return void 0;
+  let n;
+  if (typeof v === "number")
+    n = v;
+  else if (idx >= 0 && typeof v[idx] === "number")
+    n = v[idx];
+  else {
+    const present = v.filter((x) => typeof x === "number");
+    n = present.length ? Math.min(...present) : void 0;
+  }
+  if (n === void 0)
+    return void 0;
+  return Math.min(n, ceiling);
+}
+function capOf(v, idx, ceiling) {
+  if (!v)
+    return void 0;
+  const max = pick(v.max, idx, ceiling);
+  if (max === void 0)
+    return void 0;
+  const one = pick(v.one, idx, ceiling);
+  return one !== void 0 && one < max ? { max, one } : { max };
+}
+function resolveLayoutCapacity(doc, layout, ctx = {}) {
+  const packKey = ctx.pack ? `${ctx.pack}/${layout}` : null;
+  const key = packKey && doc.layouts[packKey] ? packKey : layout;
+  const raw = doc.layouts[key];
+  if (!raw)
+    return null;
+  const styleId = key === packKey ? ctx.pack : ctx.style;
+  const idx = styleId ? doc.styles.indexOf(styleId) : -1;
+  const ceiling = doc.maxUnits ?? 160;
+  const slots = {};
+  for (const [s, v] of Object.entries(raw.slots ?? {})) {
+    const c = capOf(v, idx, ceiling);
+    if (c)
+      slots[s] = c;
+  }
+  const rows = {};
+  for (const [k, r] of Object.entries(raw.rows ?? {})) {
+    const fields = {};
+    for (const [f, fv] of Object.entries(r.fields ?? {})) {
+      const lo = capOf(fv.lo, idx, ceiling);
+      const hi = capOf(fv.hi, idx, ceiling);
+      if (lo && hi)
+        fields[f] = { lo, hi };
+    }
+    rows[k] = { max: pick(r.max, idx, Number.POSITIVE_INFINITY) ?? 1, fields };
+  }
+  return { key, slots, numeric: new Set(raw.numeric ?? []), rows, charts: raw.charts ?? [] };
+}
+function rowFieldCap(field, n, max) {
+  const loN = Math.min(3, max);
+  if (n <= loN || max <= loN)
+    return field.lo;
+  if (n >= max)
+    return field.hi;
+  const t = (n - loN) / (max - loN);
+  const mix = (a, b) => Math.floor(a + (b - a) * t);
+  const one = field.lo.one !== void 0 || field.hi.one !== void 0 ? mix(field.lo.one ?? field.lo.max, field.hi.one ?? field.hi.max) : void 0;
+  const out = { max: mix(field.lo.max, field.hi.max) };
+  if (one !== void 0 && one < out.max)
+    out.one = one;
+  return out;
+}
+var ONE_LINE_SLOT = /_(?:title|name|label|head|date|dur|unit|tag|initials|role|key)$|^(?:eyebrow|badge|tag|round|kicker|featured|brand\d*|col\d+|name|label)$/;
+var NUMBERED_SLOT = /\d/;
+var CHROME_SLOT = /^(?:eyebrow|footer|pageno|meta|date|presenter|brand\d+|refs|image_label|media_label|source_label|index)$/;
+var fmtW = (n) => String(Math.round(n * 10) / 10);
+function checkSlideCapacity(slide, cap, defaults) {
+  const errors = [];
+  const warnings = [];
+  const slots = slide.slots ?? {};
+  const checkText = (where, value, c, numeric, oneLine) => {
+    const w = visualWidth(value);
+    if (w > c.max) {
+      errors.push({
+        slot: where,
+        code: "overflow",
+        message: numeric ? `${where} "${value}" will not stay on one line \u2014 it holds \u2264${fmtW(c.max)} (\u2248${Math.floor(c.max * 2)} digits); shorten the number (\u4E07/\u4EBF/K/M) or move the unit into its unit slot` : `${where} is ~${fmtW(w)} wide but holds \u2264${fmtW(c.max)} \u2014 cut ~${fmtW(w - c.max)} (CJK=1, Latin\u22480.5), or pick a roomier layout (deck-plan)`
+      });
+    } else if (oneLine && c.one !== void 0 && w > c.one) {
+      warnings.push({ slot: where, code: "wrap", message: `${where} wraps (~${fmtW(w)} wide; one line holds ${fmtW(c.one)})` });
+    }
+  };
+  for (const [name, raw] of Object.entries(slots)) {
+    const c = cap.slots[name];
+    if (!c || raw === void 0 || raw === null)
+      continue;
+    checkText(name, String(raw), c, cap.numeric.has(name), ONE_LINE_SLOT.test(name));
+  }
+  for (const [key, list] of Object.entries(slide.rows ?? {})) {
+    const r = cap.rows[key];
+    if (!r || !Array.isArray(list))
+      continue;
+    if (list.length > r.max) {
+      errors.push({
+        slot: `rows.${key}`,
+        code: "rows",
+        message: `rows.${key} has ${list.length} rows but the layout holds \u2264${r.max} \u2014 split the slide or merge rows`
+      });
+    }
+    list.forEach((row, i) => {
+      if (!row || typeof row !== "object")
+        return;
+      for (const [f, v] of Object.entries(row)) {
+        const fc = r.fields[f];
+        if (!fc || v === void 0 || v === null)
+          continue;
+        checkText(`rows.${key}[${i}].${f}`, String(v), rowFieldCap(fc, list.length, r.max), false, ONE_LINE_SLOT.test(f));
+      }
+    });
+  }
+  if (defaults) {
+    const missingNumbered = [];
+    for (const [name, def] of Object.entries(defaults)) {
+      if (name.startsWith("_") || Object.hasOwn(slots, name))
+        continue;
+      if (!def.trim())
+        continue;
+      if (NUMBERED_SLOT.test(name) && !CHROME_SLOT.test(name))
+        missingNumbered.push(name);
+      else {
+        warnings.push({
+          slot: name,
+          code: "default",
+          message: `${name} is not filled \u2014 it renders the template text "${def.replace(/<[^>]+>/g, " ").trim().slice(0, 24)}"; pass "" to leave it empty`
+        });
+      }
+    }
+    if (missingNumbered.length) {
+      errors.push({
+        slot: missingNumbered[0],
+        code: "underfill",
+        message: `${missingNumbered.join(", ")} not filled \u2014 the slide would show the template's demo copy there. Give every item this layout has, or pick a layout with fewer slots (deck-plan)`
+      });
+    }
+  }
+  return { errors, warnings };
+}
+
+// packages/core/dist/document/deck-plan.js
+function parseLayoutTable(md) {
+  const out = [];
+  for (const line of md.split("\n")) {
+    const m = /^\|\s*`([a-z0-9-]+)`\s*\|(.*)\|\s*$/.exec(line.trim());
+    if (!m)
+      continue;
+    const cells = m[2].split("|").map((c) => c.trim());
+    if (cells.length < 5)
+      continue;
+    out.push({ id: m[1], role: cells[0], structure: cells[1], density: cells[2], hasImage: cells[3], pickWhen: cells.slice(4).join("|"), order: out.length });
+  }
+  return out;
+}
+var SUFFIX_ROLE = {
+  title: "head",
+  name: "head",
+  head: "head",
+  key: "head",
+  body: "body",
+  desc: "body",
+  bio: "body",
+  text: "body",
+  num: "num",
+  val: "num",
+  value: "num",
+  stat: "num",
+  unit: "unit",
+  label: "label",
+  note: "note",
+  date: "date",
+  dur: "date",
+  initials: "initials",
+  role: "label"
+};
+var BARE_PREFIX_ROLE = { unit: "unit", label: "label", pct: "num", price: "num", num: "num", val: "num", value: "num", stat: "num", note: "note", date: "date" };
+var NUMERIC_TEXT = /^[\s\d.,%+\-−~$¥€£x×/:]*\d[\s\d.,%+\-−~$¥€£x×/:]*$/;
+function layoutStructure(slots, defaults = {}) {
+  const raw = /* @__PURE__ */ new Map();
+  const singles = [];
+  const isTable = slots.some((s) => /^r\d+c\d+$/.test(s));
+  const table = isTable ? { cols: [], keys: [], cells: [] } : null;
+  for (const s of slots) {
+    if (table) {
+      let m2 = /^r(\d+)c(\d+)$/.exec(s);
+      if (m2) {
+        (table.cells[+m2[1] - 1] ??= [])[+m2[2] - 1] = s;
+        continue;
+      }
+      m2 = /^r(\d+)_key$/.exec(s);
+      if (m2) {
+        table.keys[+m2[1] - 1] = s;
+        continue;
+      }
+      m2 = /^col(\d+)$/.exec(s);
+      if (m2) {
+        table.cols[+m2[1]] = s;
+        continue;
+      }
+    }
+    const m = /^([a-z]+?)(\d+)_([a-z]+)$/.exec(s) ?? /^([a-z]+)_(\d+)()$/.exec(s) ?? /^([a-z]+?)(\d+)()$/.exec(s);
+    if (!m) {
+      singles.push(s);
+      continue;
+    }
+    const list = raw.get(m[1]) ?? [];
+    list.push({ n: Number(m[2]), suffix: m[3], slot: s });
+    raw.set(m[1], list);
+  }
+  const byPrefix = /* @__PURE__ */ new Map();
+  for (const s of singles) {
+    const m = /^([a-z]+)_([a-z]+)$/.exec(s);
+    if (m && !raw.has(m[1]))
+      byPrefix.set(m[1], [...byPrefix.get(m[1]) ?? [], m[2]]);
+  }
+  const sig = (p) => [...byPrefix.get(p) ?? []].sort().join(",");
+  const groups = /* @__PURE__ */ new Map();
+  for (const p of byPrefix.keys())
+    if ((byPrefix.get(p)?.length ?? 0) >= 2)
+      groups.set(sig(p), [...groups.get(sig(p)) ?? [], p]);
+  for (const prefixes of groups.values()) {
+    if (prefixes.length < 2)
+      continue;
+    const name = prefixes.join("+");
+    raw.set(name, prefixes.flatMap((p, i) => (byPrefix.get(p) ?? []).map((suffix) => ({ n: i + 1, suffix, slot: `${p}_${suffix}` }))));
+    for (const p of prefixes)
+      for (const suffix of byPrefix.get(p) ?? [])
+        singles.splice(singles.indexOf(`${p}_${suffix}`), 1);
+  }
+  const families = [];
+  for (const [prefix, list] of raw) {
+    const hasHead = list.some((x) => SUFFIX_ROLE[x.suffix] === "head");
+    const members = /* @__PURE__ */ new Map();
+    for (const x of list) {
+      let role;
+      if (x.suffix)
+        role = SUFFIX_ROLE[x.suffix] ?? "other";
+      else if (NUMERIC_TEXT.test((defaults[x.slot] ?? "").trim()))
+        role = "num";
+      else
+        role = BARE_PREFIX_ROLE[prefix] ?? (hasHead ? "label" : "head");
+      members.set(x.n, [...members.get(x.n) ?? [], { slot: x.slot, role }]);
+    }
+    const all = [...members.values()].flat();
+    families.push({
+      prefix,
+      indexes: [...members.keys()].sort((a, b) => a - b),
+      members,
+      stat: all.some((m) => m.role === "num"),
+      chrome: all.every((m) => CHROME_SLOT.test(m.slot)),
+      hasHead: all.some((m) => m.role === "head"),
+      hasBody: all.some((m) => m.role === "body")
+    });
+  }
+  return { families, singles, table };
+}
+var item = (p) => typeof p === "string" ? { title: p } : p ?? {};
+var str = (v) => v === void 0 || v === null || v === "" ? void 0 : String(v);
+var initials = (s) => s.trim().slice(0, s.trim().match(/^[\x00-\x7f]/) ? 2 : 1).toUpperCase();
+var MAX_BLANKS = 2;
+var TITLE_SLOTS = ["title", "statement", "banner"];
+var SUB_SLOTS = ["subtitle", "sub", "lead", "intro", "desc", "body", "tagline", "caption", "note"];
+var SOURCE_SLOTS = ["source", "quote_attr", "person"];
+var STAT_LABEL_SLOTS = ["stat_label", "lead", "stat_note"];
+function fillMember(role, slot, it, fam, reject, blanks) {
+  switch (role) {
+    case "head": {
+      const v = str(it.title) ?? str(it.label);
+      if (v === void 0) {
+        reject.push(`${slot} needs a title for every item`);
+        return "";
+      }
+      return !fam.hasBody && str(it.body) && fam.members.get(1)?.length === 1 ? `${v}\uFF1A${it.body}` : v;
+    }
+    case "body": {
+      const v = str(it.body) ?? str(it.note);
+      if (v === void 0)
+        blanks.push(slot);
+      return v ?? "";
+    }
+    case "num": {
+      const v = str(it.value);
+      if (v === void 0) {
+        reject.push(`${slot} needs a number (value) for every item`);
+        return "";
+      }
+      return v;
+    }
+    case "unit":
+      return str(it.unit) ?? "";
+    case "label":
+      return (fam.hasHead ? str(it.label) : str(it.label) ?? str(it.title)) ?? "";
+    case "note":
+      return str(it.note) ?? (fam.hasBody ? "" : str(it.body) ?? "");
+    case "date": {
+      const v = str(it.date);
+      if (v === void 0) {
+        reject.push(`${slot} needs a date for every item`);
+        return "";
+      }
+      return v;
+    }
+    case "initials":
+      return initials(str(it.title) ?? str(it.label) ?? "");
+    default:
+      blanks.push(slot);
+      return "";
+  }
+}
+function rowField(field, it, required, reject, at) {
+  if (Object.hasOwn(it, field))
+    return it[field];
+  const role = SUFFIX_ROLE[field] ?? (field === "score" || field === "pct" || field === "hex" ? "num" : void 0);
+  let v;
+  if (role === "head")
+    v = str(it.title) ?? str(it.label);
+  else if (role === "label")
+    v = str(it.label) ?? str(it.title);
+  else if (role === "body" || role === "note")
+    v = str(it.body) ?? str(it.note);
+  else if (role === "num")
+    v = str(it.value);
+  else if (role === "date")
+    v = str(it.date);
+  if (v === void 0 && required)
+    reject.push(`${at}.${field} is required`);
+  if (v !== void 0 && (field === "pct" || field === "score")) {
+    const n = Number(String(v).replace(/%$/, ""));
+    if (!Number.isFinite(n) || field === "pct" && (n < 0 || n > 100))
+      reject.push(`${at}.${field} must be ${field === "pct" ? "a percentage 0\u2013100" : "a number"} (got "${v}")`);
+  }
+  return v;
+}
+function draftSlide(info, content, ctx) {
+  const structure = layoutStructure(info.slots, info.defaults);
+  const points = (content.points ?? []).map(item);
+  const stats = (content.stats ?? []).map(item);
+  const slots = {};
+  const blanks = [];
+  const reject = [];
+  const claimed = /* @__PURE__ */ new Set();
+  const set = (slot, v) => {
+    slots[slot] = v;
+    claimed.add(slot);
+  };
+  let usedPoints = false;
+  let usedStats = false;
+  for (const fam of structure.families) {
+    const k = fam.indexes.length;
+    if (fam.chrome) {
+      for (const ms of fam.members.values())
+        for (const m of ms)
+          set(m.slot, "");
+      continue;
+    }
+    let src = null;
+    if (fam.stat) {
+      if (stats.length === k) {
+        src = stats;
+        usedStats = true;
+      } else if (points.length === k && points.every((p) => str(p.value) !== void 0)) {
+        src = points;
+        usedPoints = true;
+      }
+    } else if (points.length === k) {
+      src = points;
+      usedPoints = true;
+    } else if (stats.length === k && !points.length) {
+      src = stats;
+      usedStats = true;
+    }
+    if (!src) {
+      const have = fam.stat ? `${stats.length} stat(s)${points.length ? ` / ${points.length} point(s)` : ""}` : `${points.length} point(s)`;
+      reject.push(`holds exactly ${k} ${fam.stat ? "numbers" : "items"} (${fam.prefix}1..${k}), content has ${have}`);
+      continue;
+    }
+    fam.indexes.forEach((n, i) => {
+      for (const m of fam.members.get(n) ?? [])
+        set(m.slot, fillMember(m.role, m.slot, src[i], fam, reject, blanks));
+    });
+  }
+  if (structure.table) {
+    const t = structure.table;
+    const nCols = t.cells[0]?.length ?? 0;
+    if (!content.table)
+      reject.push(`a ${t.keys.length}\xD7${nCols} table \u2014 give table {columns, rows}`);
+    else if (content.table.rows.length !== t.keys.length || content.table.columns.length !== t.cols.length) {
+      reject.push(`holds exactly ${t.keys.length} rows \xD7 ${t.cols.length} columns (incl. the key column), content has ${content.table.rows.length} \xD7 ${content.table.columns.length}`);
+    } else {
+      t.cols.forEach((s, j) => set(s, String(content.table.columns[j] ?? "")));
+      t.keys.forEach((s, i) => set(s, String(content.table.rows[i]?.[0] ?? "")));
+      t.cells.forEach((row, i) => row.forEach((s, j) => set(s, String(content.table.rows[i]?.[j + 1] ?? ""))));
+      usedPoints = true;
+    }
+  }
+  const fromChart = info.chart === "derived" && content.chart !== void 0 ? rowsFromChart(info.id, content.chart) : null;
+  if (fromChart && "reject" in fromChart)
+    reject.push(fromChart.reject);
+  let rows;
+  for (const [key, fields] of Object.entries(info.rows ?? {})) {
+    rows ??= {};
+    if (content.rows?.[key]) {
+      rows[key] = content.rows[key];
+      usedPoints = true;
+      continue;
+    }
+    const required = FIGURE_SPECS[info.id]?.[key]?.required ?? [];
+    const numeric = fields.some((f) => f === "score" || f === "pct");
+    const charted = fromChart && "rows" in fromChart ? fromChart.rows[key] : void 0;
+    const src = charted ?? (numeric ? stats.length ? stats : points.filter((p) => str(p.value) !== void 0) : points.length ? points : stats);
+    if (!src.length) {
+      reject.push(`rows.${key} {${fields.join(",")}} needs ${numeric ? "stats with values" : "points"}`);
+      continue;
+    }
+    if (charted) {
+    } else if (numeric)
+      usedStats = true;
+    else
+      usedPoints = true;
+    const max = ctx.cap?.rows[key]?.max;
+    if (max !== void 0 && src.length > max)
+      reject.push(`rows.${key} holds \u2264${max} rows, content has ${src.length}`);
+    const range = /\((\d+)(?:\s*[–-]\s*(\d+))?/.exec(info.density);
+    if (range && src.length < Number(range[1]))
+      reject.push(`rows.${key} reads well with ${range[1]}${range[2] ? `\u2013${range[2]}` : "+"} rows (layouts/README.md), content has ${src.length}`);
+    rows[key] = src.map((it, i) => {
+      const row = {};
+      for (const f of fields) {
+        const v = rowField(f, it, required.includes(f), reject, `rows.${key}[${i}]`);
+        row[f] = v ?? "";
+      }
+      return row;
+    });
+    for (const f of fields)
+      if (rows[key].every((r) => r[f] === ""))
+        blanks.push(`rows.${key}.${f}`);
+  }
+  const singles = structure.singles.filter((s) => !claimed.has(s));
+  const has = (s) => singles.includes(s) && !claimed.has(s);
+  const take = (names, v) => {
+    const s = names.find(has);
+    if (s !== void 0 && v !== void 0)
+      set(s, v);
+    return s;
+  };
+  const quote = typeof content.quote === "string" ? { text: content.quote } : content.quote;
+  if (has("stat")) {
+    const st = stats[0];
+    if (stats.length !== 1 || str(st.value) === void 0)
+      reject.push(`holds exactly 1 number (stat), content has ${stats.length}`);
+    else {
+      set("stat", String(st.value));
+      if (has("unit"))
+        set("unit", str(st.unit) ?? "");
+      take(STAT_LABEL_SLOTS, str(st.label) ?? str(st.title) ?? "");
+      if (has("note") && str(st.note))
+        set("note", String(st.note));
+      usedStats = true;
+    }
+  }
+  if (str(content.title) !== void 0 && !take(TITLE_SLOTS, str(content.title))) {
+    if (has("quote") && !quote)
+      set("quote", String(content.title));
+    else
+      reject.push("has no title slot");
+  }
+  if (quote) {
+    if (has("quote"))
+      set("quote", quote.text);
+    else
+      reject.push("has no quote slot");
+    take(SOURCE_SLOTS, str(quote.source) ?? "");
+  }
+  take(SUB_SLOTS, str(content.subtitle));
+  if (has("eyebrow"))
+    set("eyebrow", str(content.eyebrow) ?? "");
+  if (has("footer"))
+    set("footer", ctx.footer ?? "");
+  if (has("pageno"))
+    set("pageno", String(ctx.pageNo).padStart(2, "0"));
+  if (has("index"))
+    set("index", str(content.index) ?? "");
+  take(["meta", "presenter"], str(content.meta) ?? "");
+  for (const s of singles) {
+    if (claimed.has(s))
+      continue;
+    set(s, "");
+    if (!CHROME_SLOT.test(s))
+      blanks.push(s);
+  }
+  if (points.length && !usedPoints)
+    reject.push(`has nowhere to put ${points.length} point(s)`);
+  if (stats.length && !usedStats)
+    reject.push(`has nowhere to put ${stats.length} number(s)`);
+  if (content.slots)
+    for (const [k, v] of Object.entries(content.slots)) {
+      if (!info.slots.includes(k))
+        reject.push(`unknown slot "${k}" for this layout`);
+      else {
+        slots[k] = v;
+        const b = blanks.indexOf(k);
+        if (b >= 0)
+          blanks.splice(b, 1);
+      }
+    }
+  if (blanks.length > MAX_BLANKS)
+    reject.push(`would leave ${blanks.length} slots empty (${blanks.join(", ")}) \u2014 content for a different layout`);
+  return { slots, ...rows ? { rows } : {}, ...fromChart && "options" in fromChart ? { chartOptions: fromChart.options } : {}, blanks, reject };
+}
+var SHAPES = {
+  parallel: /grid|cards|并列|要点|icon|bento|blocks|pillar/i,
+  process: /process|step|流程|步骤|serpentine/i,
+  sequence: /process|step|流程|步骤|serpentine/i,
+  timeline: /timeline|时间|历程|milestone|gantt|排期/i,
+  compare: /compar|versus|vs|对比|before|problem|问题|do & don/i,
+  hierarchy: /hierarch|pyramid|tree|层级|组织/i,
+  matrix: /quadrant|2x2|象限|matrix/i,
+  list: /list|清单|numbered/i,
+  metrics: /kpi|stat|number|指标|数字/i,
+  quote: /quote|金句|引言/i,
+  table: /table|数据表/i,
+  agenda: /agenda|议程|目录/i
+};
+var STRUCTURAL = /* @__PURE__ */ new Set(["cover", "toc", "section", "ending", "title", "transition"]);
+function roleOf(info) {
+  return info.role.split(/[\s·]+/)[0];
+}
+function roleMatches(info, role) {
+  const r = roleOf(info);
+  if (role === "content")
+    return r === "content" || r === "pitch";
+  if (role === "section")
+    return r === "section" || r === "title" || r === "transition";
+  return r === role;
+}
+var needsImage = (info) => /\*\*/.test(info.hasImage) && /photo|image|media|map slot/.test(info.hasImage);
+var takesImage = (info) => needsImage(info) || /optional/.test(info.hasImage);
+function densityWanted(n) {
+  return n <= 2 ? "light" : n <= 4 ? "medium" : "dense";
+}
+function evaluate(info, content, ctx, deck, pageNo, intentRank) {
+  const cap = ctx.capacity ? resolveLayoutCapacity(ctx.capacity, info.id, { style: deck.style, pack: typeof deck.layoutPack === "string" && deck.layoutPack !== "none" ? deck.layoutPack : null }) : null;
+  const draft = draftSlide(info, content, { footer: typeof deck.footer === "string" ? deck.footer : void 0, pageNo, cap });
+  const errors = [...draft.reject];
+  const warnings = [];
+  if (cap && !errors.length) {
+    const r = checkSlideCapacity({ layout: info.id, slots: draft.slots, rows: draft.rows }, cap, info.defaults);
+    errors.push(...r.errors.map((f) => f.message));
+    warnings.push(...r.warnings.map((f) => f.message));
+  }
+  let score = 0;
+  if (intentRank >= 0)
+    score += 40 - 3 * intentRank;
+  const shape = content.shape ? SHAPES[content.shape] : void 0;
+  if (shape && shape.test(`${info.id} ${info.structure} ${info.pickWhen}`))
+    score += 12;
+  const n = Math.max(content.points?.length ?? 0, content.stats?.length ?? 0);
+  if (n && info.density.startsWith(densityWanted(n)))
+    score += 4;
+  if (content.image && takesImage(info))
+    score += 10;
+  if (draft.chartOptions)
+    score += 12;
+  score -= 4 * draft.blanks.length + 2 * warnings.length + info.order * 0.01;
+  return { layout: info.id, score: Math.round(score * 100) / 100, draft, warnings, errors };
+}
+function derivedChartMismatch(layout, chart) {
+  const r = rowsFromChart(layout, chart);
+  return "reject" in r ? r.reject : null;
+}
+function planDeck(deck, ctx) {
+  const v2 = deck.themeVersion === 2;
+  const used = /* @__PURE__ */ new Map();
+  const structuralPick = /* @__PURE__ */ new Map();
+  let prev = null;
+  const slides = [];
+  const specSlides = [];
+  (Array.isArray(deck.slides) ? deck.slides : []).forEach((content, i) => {
+    const role = content.role ?? "content";
+    const intent = content.intent ? ctx.intents?.[content.intent] : void 0;
+    const intentList = intent?.candidates ?? [];
+    let pool = ctx.layouts.filter((l) => content.layout ? l.id === content.layout : roleMatches(l, role));
+    const rejected = [];
+    if (content.layout && !pool.length)
+      rejected.push({ layout: content.layout, why: "unknown layout" });
+    pool = pool.filter((l) => {
+      const why = l.v2Only && !v2 ? "needs themeVersion: 2" : content.chart !== void 0 && !l.chart ? "has no chart slot" : content.chart !== void 0 && l.chart === "derived" ? derivedChartMismatch(l.id, content.chart) : content.chart === void 0 && l.chart === true ? "has a chart \u2014 give chart data or pick another" : content.image && !takesImage(l) ? "has no image slot" : !content.image && needsImage(l) ? "needs an image" : null;
+      if (why && content.layout)
+        rejected.push({ layout: l.id, why });
+      return !why;
+    });
+    const cands = pool.map((l) => evaluate(l, content, ctx, deck, i + 1, intentList.indexOf(l.id)));
+    const fits = cands.filter((c) => !c.errors.length).sort((a, b) => b.score - a.score || a.layout.localeCompare(b.layout));
+    for (const c of cands.filter((x) => x.errors.length).sort((a, b) => b.score - a.score))
+      rejected.push({ layout: c.layout, why: c.errors[0] });
+    const structural = STRUCTURAL.has(role);
+    let pick2;
+    const warnings = [];
+    if (structural && structuralPick.has(role))
+      pick2 = fits.find((c) => c.layout === structuralPick.get(role));
+    if (!pick2)
+      pick2 = structural ? fits[0] : fits.find((c) => c.layout !== prev && (used.get(c.layout) ?? 0) < 2);
+    if (!pick2 && fits.length) {
+      pick2 = fits[0];
+      warnings.push(`every fitting layout is already used twice / on the previous slide \u2014 repeating ${pick2.layout}`);
+    }
+    if (pick2) {
+      if (structural && !structuralPick.has(role))
+        structuralPick.set(role, pick2.layout);
+      used.set(pick2.layout, (used.get(pick2.layout) ?? 0) + 1);
+      prev = structural ? null : pick2.layout;
+      warnings.push(...pick2.warnings);
+    }
+    const spec = pick2 ? {
+      layout: pick2.layout,
+      ...content.intent && ctx.intents?.[content.intent] ? { intent: content.intent } : {},
+      slots: pick2.draft.slots,
+      ...pick2.draft.rows ? { rows: pick2.draft.rows } : {},
+      ...pick2.draft.chartOptions ? Object.keys(pick2.draft.chartOptions).length ? { chart: pick2.draft.chartOptions } : {} : content.chart !== void 0 ? { chart: content.chart } : {}
+    } : null;
+    if (spec)
+      specSlides.push(spec);
+    slides.push({
+      slide: i + 1,
+      pick: pick2?.layout ?? null,
+      spec,
+      warnings,
+      blanks: pick2?.draft.blanks ?? [],
+      alternatives: fits.filter((c) => c !== pick2).slice(0, 3).map((c) => ({ layout: c.layout, score: c.score })),
+      rejected: rejected.slice(0, 8)
+    });
+  });
+  const ok = slides.length > 0 && slides.every((s) => s.pick);
+  const { slides: _drop, footer: _footer, ...rest } = deck;
+  return {
+    ok,
+    slides,
+    spec: ok ? { ...rest, chartRender: deck.chartRender ?? "svg", slides: specSlides } : null
+  };
+}
+
+// apps/admin/data/skills.lib/document/bin-src/deck-plan.mjs
+function die(msg, code = 1) {
+  process.stderr.write(`deck-plan: ${msg}
+`);
+  process.exit(code);
+}
+async function main() {
+  const [planPath, outPath] = process.argv.slice(2).filter((a) => !a.startsWith("--"));
+  if (!planPath) die("usage: deck-plan <plan.json> [spec.json]", 64);
+  let plan;
+  try {
+    plan = JSON.parse(await (0, import_promises.readFile)(planPath, "utf8"));
+  } catch (e) {
+    die(`cannot read plan ${planPath}: ${e.message}`, 66);
+  }
+  if (!Array.isArray(plan?.slides) || !plan.slides.length) die("plan needs a non-empty slides array", 64);
+  const skillDir = (0, import_node_path.dirname)((0, import_node_path.dirname)(process.argv[1] || ""));
+  const layoutsDir = (0, import_node_path.join)(skillDir, "layouts");
+  const read = (f) => JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(layoutsDir, f), "utf8"));
+  const slots = read("slots.json");
+  const profiles = (0, import_node_fs.existsSync)((0, import_node_path.join)(layoutsDir, "profiles.json")) ? read("profiles.json") : {};
+  const capacityPath = (0, import_node_path.join)(layoutsDir, "capacity.json");
+  const capacity = (0, import_node_fs.existsSync)(capacityPath) ? parseCapacityDoc(read("capacity.json")) : null;
+  if (!capacity) process.stderr.write("deck-plan: layouts/capacity.json missing \u2014 fit is checked by item count only\n");
+  const pack = typeof plan.layoutPack === "string" && plan.layoutPack !== "none" ? plan.layoutPack : null;
+  const tplOf = (id) => {
+    const own = pack ? (0, import_node_path.join)(skillDir, "packs", pack, "layouts", `${id}.tpl`) : null;
+    if (own && (0, import_node_fs.existsSync)(own)) return (0, import_node_fs.readFileSync)(own, "utf8");
+    const p = (0, import_node_path.join)(layoutsDir, `${id}.tpl`);
+    return (0, import_node_fs.existsSync)(p) ? (0, import_node_fs.readFileSync)(p, "utf8") : null;
+  };
+  const v2 = new Set(profiles.themeV2Layouts ?? []);
+  const layouts = [];
+  for (const row of parseLayoutTable((0, import_node_fs.readFileSync)((0, import_node_path.join)(layoutsDir, "README.md"), "utf8"))) {
+    const entry = slots[row.id];
+    const tpl = entry ? tplOf(row.id) : null;
+    if (!entry || !tpl) continue;
+    const defaults = templateDefaults(tpl);
+    layouts.push({ ...row, slots: Object.keys(defaults), rows: entry.rows, chart: entry.chart, defaults, v2Only: v2.has(row.id) });
+  }
+  const result = planDeck(plan, { layouts, capacity, intents: profiles.intents ?? {} });
+  if (outPath && result.ok) await (0, import_promises.writeFile)(outPath, JSON.stringify(result.spec, null, 1) + "\n", "utf8");
+  process.stdout.write(JSON.stringify({
+    ok: result.ok,
+    ...outPath ? { out: result.ok ? outPath : null } : {},
+    slides: result.slides.map(({ spec, ...s }) => outPath ? s : { ...s, spec }),
+    next: result.ok ? `deck-build ${outPath ?? "spec.json"} deck.html` : "fix the slides with pick:null (see rejected[].why): change the content's item count / length, or pin a layout and pass its slots"
+  }, null, 1) + "\n");
+  if (!result.ok) process.exit(1);
+}
+main().catch((e) => die(e.message, 1));