slidemind 0.3.19 → 0.4.0

package/src/builders/concept-text.mjs

@@ -0,0 +1,140 @@
+// Text the reader reported that is the model talking about the ABSENCE of
+// text, not a slide's words. A leaf module: the line intake needs it (a
+// placeholder disc is wordless) and concept-spec imports the line intake.
+// The model writes the literal ">null" for an absent text now and then, and a
+// lone syntax mark ("." on a divider) the same way.
+// The model's stand-ins for "no text" under a strict schema, observed across
+// runs: ">null", "><null>", "/null", "/body", ">", "There is no text.".
+const NO_TEXT = /^\W*(?:null|no text|there is no text|no visible text)\W*$/i;
+// …and a string made only of SYNTAX: brackets, slashes, separators, quotes.
+// That is what leaks when the model has no words to report, and no slide
+// prints it.
+//
+// This replaced "no letter or digit", which was the same idea stated far too
+// widely and deleted real copy (E26): an em-dash column meaning "not
+// applicable", a ✓/✗ comparison matrix, a bullet glyph used as a value, a "?"
+// cell for an unknown. Those are typography, not syntax — a slide's own words
+// even when they carry no letter. ">" and "." still go, because they are.
+const STRUCTURAL_ONLY = /^[<>/\\|:=.,;'"`()[\]{}\s]+$/;
+// …and any lone token wrapped in slashes or angle brackets ("/slide", "<img>")
+// — the model's placeholder grammar, never a slide's words.
+const TOKEN_ONLY = /^[<>\/\\]+[A-Za-z_-]{1,24}[<>\/\\]*$/;
+// …and any spaceless token that carries BOTH an angle bracket and a slash:
+// markup the model leaked instead of words ("></xsl:value-of>", x38 ×26). By
+// shape, not by list — the exact scrap changes between runs. A threshold like
+// ">45%" has no slash and survives; "50/50" has no bracket.
+const MARKUP_ONLY = /^(?=\S{1,40}$)(?=[^\s]*[<>])(?=[^\s]*[/\\])\S+$/;
+// …and any short SPACELESS token that carries "null" as a segment ("s:null",
+// "x=null"). The `\S{1,24}` lookahead is load-bearing: `.{1,24}` let a space
+// close the segment, so "null pointer" and "null hypothesis" — two real
+// phrases — were deleted as symbols (E26).
+const NULL_SEGMENT = /^(?=\S{1,24}$)\S*(?:^|[^a-z])null(?:[^a-z]|$)\S*$/i;
+
+/**
+ * The text a slide should print, or null when the string is the model talking
+ * about the absence of text rather than reporting it.
+ *
+ * `printed` is the reader's own classification (`textSource === "visible"`:
+ * "those characters are printed in the image"). It suppresses the two rules
+ * that cannot be decided by shape alone — the word "null" and its symbol
+ * forms, which are a stand-in in one deck and a table cell's value in the
+ * next. It does NOT suppress the markup rules: leaked syntax is never a
+ * slide's words, whatever the reader claims about it (x38 shipped
+ * "></xsl:value-of>" 26 times under exactly that claim).
+ *
+ * Deleting copy still needs an explicit classification the other way — that is
+ * `dropStandIns`, which has the element and honours `textSource:
+ * "placeholder"` above everything here.
+ */
+export function cleanText(t, { printed = false } = {}) {
+  if (t == null) return null;
+  const s = String(t).trim();
+  if (s === "" || STRUCTURAL_ONLY.test(s) || TOKEN_ONLY.test(s) || MARKUP_ONLY.test(s)) return null;
+  if (!printed && (NO_TEXT.test(s) || NULL_SEGMENT.test(s))) return null;
+  return typeof t === "string" ? typeset(t) : t;
+}
+
+// The concept image model writes typography the approved plan never had — a
+// clause em-dash, curly quotes — and our own content lint then sent the agent
+// to hand-patch what the transcriber wrote (T21: em-dash 101 of 113 slide
+// occurrences first appeared at transcribe). So slide copy is typeset once,
+// here, for every consumer of the spec. A dash that JOINS words becomes the
+// punctuation the lint names: ": " when spaced, ", " when closed, commas for a
+// parenthetical pair, an en-dash between two numbers, spaced or closed
+// ("2020 — 2024", "Q1—Q3", "10 — 20%") or from a number to now ("2020—present":
+// a range); a dash opening the text goes. A dash that IS the value — an N/A cell "—", "—%", a legend
+// "— = not reported" — stays (E26). Curly quotes straighten, except a German
+// „…“ pair, which is correct typography. `quote` is what a double quote
+// becomes: chrome props are JSX attribute strings, where a straight `"`
+// cannot be escaped, so they pass "'".
+// A word end may carry closers, the German “ ‘ among them (`„Zitat“ — sagte er`).
+const CLAUSE_DASH = /(?<=[\p{L}\p{N}][)\]"'’”“‘%]*)(\s*)—(\s*)(?=[(["'‘“„]*[\p{L}\p{N}])/gu;
+const LEADING_DASH = /^(\s*)—\s*(?=[(["'‘“„]*[\p{L}\p{N}])/u;
+// An open end ("present") counts only where it ends the phrase: "2019 — today
+// 40 teams" is a clause.
+const RANGE_DASH = /(?<=\d[\p{L}%]*)\s*—\s*(?=\p{L}*\d|(?:present|today|now|heute)(?![ \t]*[\p{L}\p{N}]))/giu;
+export function typeset(text, { quote = '"' } = {}) {
+  const doubles = quote === '"' ? /(„[^“”„]*[“”])|[“”]/g : /(„[^“”„"]*[“”])|[“”"]/g;
+  return String(text)
+    .replace(RANGE_DASH, "–")
+    .replace(/[^.!?]*[.!?]*/g, (sentence) => {
+      const pair = (sentence.match(CLAUSE_DASH) ?? []).length > 1;
+      return sentence.replace(CLAUSE_DASH, (_, a, b) => `${pair || !/[^\S\n]/.test(a + b) ? "," : ":"}${/\n/.test(a + b) ? "\n" : " "}`);
+    })
+    .replace(LEADING_DASH, "$1")
+    .replace(doubles, (m, german) => german ?? quote)
+    .replace(/[‘’]/g, "'");
+}
+
+// The spec's `\n` is where the image breaks the line. A line that starts with
+// a bullet, a relation sign, a number or a capital is a new line (a list item,
+// a new sentence, a threshold, a stacked label); one that starts lower-case or
+// indented continues the previous line (a paragraph wrap the box width
+// reproduces on its own). A wrap after a hyphen splits a compound
+// ("revenue-\noperations"): it rejoins without a space.
+// x27: joining everything collapsed every bullet list into one run of text.
+// x37 GTM 4: a threshold column (">45%", ">60%") came out as one run — a
+// relation sign opens a line as surely as a bullet does.
+const NEW_LINE = /^(?:[•·‣*\-–▪◦✓✔→<>≥≤±~]|\d+[.)]\s|[A-ZÄÖÜ0-9])/;
+export function textLines(s) {
+  const out = [];
+  for (const raw of String(s).split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (out.length && !BULLET.test(line) && !(NEW_LINE.test(line) && !/^\s/.test(raw))) out[out.length - 1] += `${/\p{L}-$/u.test(out[out.length - 1]) ? "" : " "}${line}`;
+    else out.push(line);
+  }
+  return out;
+}
+
+// A list marker typed into the text: a bullet-like glyph or a tick, then the
+// item's words. The glyph is the image's drawing of the marker; the list is
+// structure (concept-lists.mjs): the item ships as a native PowerPoint bullet
+// in the design's own glyph, hanging its wrapped lines under the text. A
+// numbered line ("1. Plan") is a heading or a step unless the reader declared
+// it an item, so no number is read here.
+const BULLET = /^([•·▪◦‣●■□◆\-–*✓✔✗✘])[ \t]+(?=\S)/;
+// A declared number item may still carry its ordinal in the text ("1. Plan").
+const ORDINAL = /^(?:\d{1,2}|[a-z])[.)][ \t]+(?=\S)/i;
+/** The marker kind a line opens with (`bullet` | `check` | `cross`), or null. */
+export function markerOfLine(line) {
+  const glyph = BULLET.exec(String(line ?? ""))?.[1];
+  return glyph ? (/[✓✔]/.test(glyph) ? "check" : /[✗✘]/.test(glyph) ? "cross" : "bullet") : null;
+}
+/** The line without the marker the reader typed into it (`kind` decides what counts as one). */
+export function stripMarker(line, kind) {
+  const s = String(line ?? "");
+  return kind === "number" ? s.replace(ORDINAL, "") : s.replace(BULLET, "");
+}
+
+// A text whose every line opens with the SAME marker is a bullet list.
+export function bulletItems(text) {
+  const lines = textLines(text ?? "");
+  if (lines.length < 2) return null;
+  const markers = lines.map((l) => BULLET.exec(l)?.[1] ?? null);
+  if (markers.some((m) => m == null) || new Set(markers).size !== 1) return null;
+  return { marker: markers[0], items: lines.map((l) => l.replace(BULLET, "")) };
+}
+
+/** Did the reader say these characters are printed on the image? */
+export const textIsPrinted = (e) => e?.textSource === "visible";

package/src/builders/concept-waves.mjs

@@ -0,0 +1,57 @@
+import { splitPlanMarkdownIntoSegments } from "./storyboard-markdown.mjs";
+
+// The slide numbers the plan's storyboards actually carry, ascending. This is
+// the set concept generation must cover — the server's slideCount is only the
+// number of beats IT parsed, and one beat it drops (an older schema rejecting
+// a cover's empty block list) would otherwise also drop the LAST slide from a
+// 2..slideCount request range.
+export function plannedSlideNumbers(planMarkdown) {
+  const slides = new Set();
+  for (const segment of splitPlanMarkdownIntoSegments(planMarkdown)) {
+    if (segment.type !== "storyboard" || !segment.data) continue;
+    if (Number.isFinite(segment.data.slide)) slides.add(segment.data.slide);
+  }
+  return [...slides].sort((a, b) => a - b);
+}
+
+/**
+ * Split a per-slide concept batch into dependency waves: every slide that
+ * continues no earlier slide first, then each slide one wave after the slide
+ * its storyboard `continues`. The add-in caches every continued concept, so a
+ * later wave's request finds the predecessor an earlier wave made.
+ */
+export function conceptGenerationWaves(planMarkdown) {
+  const planned = plannedSlideNumbers(planMarkdown);
+  const previous = new Map();
+  for (const segment of splitPlanMarkdownIntoSegments(planMarkdown)) {
+    if (segment.type !== "storyboard" || !segment.data) continue;
+    const { slide, continues } = segment.data;
+    // The parser keeps only backward links, so the chains below always end.
+    if (planned.includes(continues)) previous.set(slide, continues);
+  }
+  const depth = (slide) => (previous.has(slide) ? depth(previous.get(slide)) + 1 : 0);
+  const waves = [];
+  for (const slide of planned) (waves[depth(slide)] ??= []).push(slide);
+  return waves;
+}
+
+/**
+ * A slide and every earlier slide its storyboard's `continues` chain reaches,
+ * in that order — the slides whose image uses its concept depends on. The
+ * add-in walks the same links (`continuationChain` in concept-sequence.ts).
+ */
+export function continuationChain(planMarkdown, slide) {
+  const continues = new Map();
+  for (const segment of splitPlanMarkdownIntoSegments(planMarkdown)) {
+    if (segment.type !== "storyboard" || !segment.data) continue;
+    continues.set(segment.data.slide, segment.data.continues);
+  }
+  const chain = [];
+  for (let s = slide; s !== undefined && !chain.includes(s); ) {
+    chain.push(s);
+    const previous = continues.get(s);
+    // Only backward links: a forward or self link ends the chain.
+    s = Number.isFinite(previous) && previous < s ? previous : undefined;
+  }
+  return chain;
+}

package/src/builders/copy-fit.mjs

@@ -0,0 +1,139 @@
+// Copy-fit: the type is the slide's one ladder on the design's ramp; where a
+// text still runs past the room the image gives it after the settle fit (and
+// after the ladder's one step down), its WORDS shorten, never its size. One
+// batched model call per slide, made by the client (settle-driver.mjs
+// `fitCopy`); the next settle render re-measures the result.
+// Mirrored into the add-in by scripts/sync-transcription-runtime.mjs — no Node
+// or CLI imports here.
+import { hardLineCount, textRoom } from "./settle.mjs";
+
+const HEAD = new Set(["title", "section", "number", "badge"]);
+const BULLET = /^\s*[•●▪■◦○\-–—✓✔→►▸]\s/;
+// A label or heading keeps its words: shortening "Q3 revenue" says less, not the same in less room.
+const MIN_WORDS = 4;
+// A budget under this share of the text means the box is wrong, not the copy.
+const MIN_SHARE = 0.25;
+// Budgets aim a little under the room: the rewrite is measured only by the next render.
+const MARGIN = 0.95;
+
+const flat = (t) => String(t ?? "").replace(/\s+/g, " ").trim();
+const words = (t) => flat(t).split(" ").filter(Boolean).length;
+const fixed = (t) => t.role === "number" || t.kind === "number" || String(t.text ?? "").split("\n").some((l) => BULLET.test(l));
+// Characters a line of the box holds: a wrapped text fills every line but its
+// last, which is half full on average.
+const perLine = (chars, lines, fill = 1) => (chars / Math.max(0.5, lines - 0.5)) * Math.min(1.2, Math.max(1, fill));
+const prefixOf = (t) => (t.leadIn ? String(t.leadIn).trim().replace(/[:\s]+$/, "") : null);
+
+/**
+ * The texts on a settled slide that still run past their room, each with a
+ * character budget: `{ id, el, para, role, text, maxChars, wrap, keepPrefix?, why? }`.
+ * `why` marks one copy-fit leaves alone (`short`, `geometry`, `fixed`); the
+ * overrun still counts for the ladder's step down. `tighten` scales every
+ * budget (the second round asks for less).
+ */
+export function textOverruns(spec, measured, { tighten = 1 } = {}) {
+  const slot = spec.slot;
+  const byId = new Map((spec.elements ?? []).map((e) => [e.id, e]));
+  const out = [];
+  const push = (e, para, t, lines, cpl, wrap, lineCount, held = false) => {
+    const text = flat(t.text);
+    const maxChars = Math.floor(lines * cpl * MARGIN * tighten);
+    const why = held || fixed(t) ? "fixed" : words(text) < MIN_WORDS ? "short" : maxChars < MIN_SHARE * text.length ? "geometry" : null;
+    out.push({ id: para == null ? e.id : `${e.id}#${para}`, el: e.id, para, role: t.role ?? e.role ?? "body", text, maxChars, wrap, lines: lineCount, maxLines: lines,
+      ...(prefixOf(t) ? { keepPrefix: prefixOf(t) } : {}), ...(why ? { why } : {}) });
+  };
+  for (const e of spec.elements ?? []) {
+    if (!(e.kind === "text" || e.kind === "number") || e.text == null || e.textRotation || e.textFrame) continue;
+    const m = measured.get(e.id);
+    if (!(m?.inkWidth > 0) || !(m.lines > 0) || !(e.w > 0 && e.h > 0)) continue;
+    const r = textRoom(spec, e, { slot, byId });
+    const lineH = (m.inkHeight ?? m.h) / m.lines;
+    const top = m.inkY ?? m.y;
+    // The lines the room holds from where the text starts.
+    const room = Math.max(1, Math.floor((e.y + r.h - top + 1) / lineH));
+    const text = flat(e.text);
+    if (!e.paragraphs?.length) {
+      if (m.lines > room) push(e, null, e, room, perLine(text.length, m.lines, e.w / m.inkWidth), true, m.lines);
+      // A line the settle fit could neither widen nor wrap: shorter on one line.
+      else if (m.inkWidth > r.w + 1 && m.lines <= hardLineCount(e)) push(e, null, e, 1, (text.length * r.w) / m.inkWidth, false, m.lines);
+      continue;
+    }
+    if (m.lines <= room) continue;
+    // A block: headings keep their lines, the body paragraphs share the rest.
+    const paras = e.paragraphs;
+    const share = paras.map((p) => flat(p.text).length);
+    const per = m.paraLines?.length === paras.length ? m.paraLines
+      : share.map((n) => Math.max(1, Math.round((m.lines * n) / Math.max(1, share.reduce((a, b) => a + b, 0)))));
+    const body = paras.map((_, i) => i).filter((i) => !HEAD.has(paras[i].role) && !fixed(paras[i]));
+    const left = room - per.reduce((n, l, i) => n + (body.includes(i) ? 0 : l), 0);
+    const bodyLines = body.reduce((n, i) => n + per[i], 0);
+    for (const i of body) {
+      const lines = Math.max(1, Math.floor((left * per[i]) / Math.max(1, bodyLines)));
+      if (per[i] > lines) push(e, i, paras[i], lines, perLine(share[i], per[i]), true, per[i]);
+    }
+    if (!body.length) push(e, null, e, room, perLine(text.length, m.lines), true, m.lines, true);
+  }
+  return out;
+}
+
+/** The plan's words for one slide (its storyboard beat), as the prompt quotes them. */
+function planLines(beat) {
+  if (!beat) return "";
+  const notes = Array.isArray(beat.contentNotes) ? beat.contentNotes : [];
+  return [beat.keyMessage ? `Key message: ${beat.keyMessage}` : "", notes.length ? `Content notes:\n- ${notes.join("\n- ")}` : ""].filter(Boolean).join("\n");
+}
+
+/** Every visible text on the slide, one line: the rewrite keeps the slide's voice. */
+export const slideContext = (spec) => (spec.elements ?? []).filter((e) => e.text != null && e.kind !== "icon").map((e) => flat(e.text)).filter(Boolean).join(" | ");
+
+export const COPY_FIT_SCHEMA = {
+  type: "object", additionalProperties: false, required: ["items"],
+  properties: { items: { type: "array", items: { type: "object", additionalProperties: false, required: ["id", "text"], properties: { id: { type: "string" }, text: { type: "string" } } } } },
+};
+
+/** The one request for a slide: `items` are `{ id, role, text, maxChars, keepPrefix? }`. */
+export function copyFitPrompt({ items, context = "", plan = null }) {
+  const plain = planLines(plan);
+  return [
+    "You fit slide copy into fixed text boxes. The type size is fixed by the brand; only the words may change.",
+    "For each item, rewrite `text` to at most `maxChars` characters (count spaces), as one piece of natural copy: full phrases or a sentence, never a list of fragments.",
+    "Write plain, natural slide copy a consultant would put on a slide. Keep the language of the original and its key message.",
+    "To save space, first drop filler, hedges, redundancy and secondary clauses, then secondary facts; keep the headline number of the text.",
+    "Never abbreviate words (no 'Vol.', 'incr.', 'exp'), never use telegraphic shorthand, slashes or semicolon lists, never invent facts, no ellipsis.",
+    "Keep list numbering and prefixes like '1.' or '4.'. Keep the capitalization style and end punctuation style of the original.",
+    "If `keepPrefix` is given, the text must still start with it verbatim.",
+    "",
+    ...(plain ? ["The APPROVED PLAN for this slide is below. Its facts, figures and claims are what must survive; words the mockup added beyond the plan go first.", plain, ""] : []),
+    `Slide context (all texts on the slide): ${context}`,
+    "",
+    `Items: ${JSON.stringify(items.map(({ id, role, text, maxChars, keepPrefix }) => ({ id, role, text, maxChars, ...(keepPrefix ? { keepPrefix } : {}) })))}`,
+  ].join("\n");
+}
+
+/**
+ * The spec with each answered text in place: `answers` is `[{ id, text }]`.
+ * A rewrite that is no shorter, or lost its lead-in, is dropped. Returns
+ * `{ spec, changes }`.
+ */
+export function applyCopyFit(spec, items, answers) {
+  const s = structuredClone(spec);
+  const byId = new Map(s.elements.map((e) => [e.id, e]));
+  const said = new Map((answers ?? []).map((a) => [a?.id, flat(a?.text)]));
+  const changes = [];
+  for (const item of items) {
+    const text = said.get(item.id);
+    const e = byId.get(item.el);
+    if (!text || !e || text.length >= item.text.length) continue;
+    if (item.keepPrefix && !text.startsWith(item.keepPrefix)) continue;
+    const t = item.para == null ? e : e.paragraphs?.[item.para];
+    if (!t) continue;
+    t.text = text;
+    if (Array.isArray(t.emphasis)) t.emphasis = t.emphasis.filter((x) => text.includes(flat(x)));
+    if (Array.isArray(t.runs)) t.runs = t.runs.filter((r) => text.includes(flat(r.text)));
+    if (item.para != null) e.text = e.paragraphs.map((p) => p.text).join("\n");
+    // A paragraph that wrapped keeps wrapping, however short it got.
+    if (item.wrap) e.wrap = true;
+    changes.push(`${item.id}: copy ${item.text.length}→${text.length} characters to fit its room (${item.lines} lines, room for ${item.maxLines})`);
+  }
+  return { spec: s, changes };
+}