slidemind 0.3.20 → 0.4.0

package/src/builders/storyboard-schema.mjs

@@ -1,33 +1,26 @@
-// Storyboard-canvas schema: the defensive parser/serializer for the JSON block a
-// plan.md carries inside each ```storyboard-canvas``` fence. Ported 1:1 from the
-// add-in's src/ui/src/pages/plan-review/storyboard-schema.ts (TS types dropped;
-// every constant, regex, clamp and branch identical). This module also ships into
-// the plan gate's browser bundle, concatenated with the other plan modules into a
-// single IIFE — so module-scope helpers use an `sb`/`SB_` prefix to stay unique
-// across that shared scope, while the exported API names match the add-in exactly.
+// The per-slide plan record: the defensive parser/serializer for the JSON block a
+// plan.md carries inside each ```storyboard-canvas``` fence. It holds the three
+// things a human signs off — the story beat, the content points, the layout —
+// plus the agent's own bookkeeping (role, sequence link, layout provenance,
+// image direction) and — since the image-intent contract — the slide's
+// `assetUses`, the approved obligations for the deck's imported images
+// (src/lib/image-intent.mjs). It deliberately holds NO design input: no blocks, no
+// geometry, no design-element names. Composition is decided by the concept
+// generator from the story, the content and the layout's own content region,
+// not guessed at plan time in a coordinate space nobody reviewed. The fence
+// keeps its name so every producer and consumer reads unchanged.
+// Canonical here;
+// the add-in imports a byte-identical mirror (scripts/sync-transcription-runtime.mjs),
+// typed by its src/ui/src/pages/plan-review/storyboard-schema.ts. This module also
+// ships into the plan gate's browser bundle, concatenated with the other plan
+// modules into a single IIFE — so module-scope helpers use an `sb`/`SB_` prefix
+// to stay unique across that shared scope.
+
+import { validateSlideUses } from "../lib/image-intent.mjs";
 
 export const STORYBOARD_CANVAS_LANG = "storyboard-canvas";
-export const STORYBOARD_WIDTH = 1600;
-export const STORYBOARD_HEIGHT = 900;
-
-export const BODY_SAFE_AREA = {
-  x: 80,
-  y: 110,
-  w: 1440,
-  h: 670,
-};
-
-export const MIN_BLOCK_WIDTH = 180;
-export const MIN_BLOCK_HEIGHT = 96;
-export const MAX_BLOCKS = 8;
-const SB_MAX_ID_LENGTH = 64;
-export const MAX_DESIGN_ELEMENT_LENGTH = 56;
-export const MAX_CONTENT_LENGTH = 28;
 const SB_MAX_KEY_MESSAGE_LENGTH = 180;
-const SB_MAX_VISUAL_FAMILY_LENGTH = 64;
 const SB_MAX_LAYOUT_NAME_LENGTH = 64;
-const SB_MAX_DEPTH_NOTES = 6;
-const SB_MAX_DEPTH_NOTE_LENGTH = 220;
 export const MAX_IMAGE_PROMPT_LENGTH = 240;
 const SB_MAX_IMAGE_PROMPTS = 4;
 const SB_IMAGE_PROMPT_KEY = /^image\d{0,2}$/;
@@ -45,64 +38,6 @@ function sbAsFiniteNumber(value, fallback) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 
-function sbClamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
-
-function sbNormalizeBlock(value, index, warnings) {
-  if (!sbIsRecord(value)) {
-    warnings.push(`Block ${index + 1} is not an object and was ignored.`);
-    return null;
-  }
-
-  const id = sbAsTrimmedString(value.id, SB_MAX_ID_LENGTH) || `block-${index + 1}`;
-  const designElement = sbAsTrimmedString(
-    value.designElement,
-    MAX_DESIGN_ELEMENT_LENGTH,
-  );
-  const content = sbAsTrimmedString(value.content, MAX_CONTENT_LENGTH);
-  if (!designElement || !content) {
-    warnings.push(
-      `Block "${id}" needs both designElement and content and was ignored.`,
-    );
-    return null;
-  }
-
-  const minW = MIN_BLOCK_WIDTH;
-  const minH = MIN_BLOCK_HEIGHT;
-  const maxW = BODY_SAFE_AREA.w;
-  const maxH = BODY_SAFE_AREA.h;
-  const w = sbClamp(sbAsFiniteNumber(value.w, 360), minW, maxW);
-  const h = sbClamp(sbAsFiniteNumber(value.h, 150), minH, maxH);
-  const x = sbClamp(
-    sbAsFiniteNumber(value.x, BODY_SAFE_AREA.x),
-    BODY_SAFE_AREA.x,
-    BODY_SAFE_AREA.x + BODY_SAFE_AREA.w - w,
-  );
-  const y = sbClamp(
-    sbAsFiniteNumber(value.y, BODY_SAFE_AREA.y),
-    BODY_SAFE_AREA.y,
-    BODY_SAFE_AREA.y + BODY_SAFE_AREA.h - h,
-  );
-  const emphasis =
-    value.emphasis === "primary" ||
-    value.emphasis === "secondary" ||
-    value.emphasis === "tertiary"
-      ? value.emphasis
-      : undefined;
-
-  return {
-    id,
-    x,
-    y,
-    w,
-    h,
-    ...(emphasis ? { emphasis } : {}),
-    designElement,
-    content,
-  };
-}
-
 export function parseStoryboardCanvas(raw) {
   let parsed;
   try {
@@ -129,33 +64,8 @@ export function parseStoryboardCanvas(raw) {
   }
 
   const slide = Math.max(1, Math.round(sbAsFiniteNumber(parsed.slide, 1)));
-  const rawBlocks = Array.isArray(parsed.blocks) ? parsed.blocks : [];
-  if (!Array.isArray(parsed.blocks)) {
-    warnings.push("Storyboard blocks must be an array.");
-  }
-
-  const blocks = rawBlocks
-    .slice(0, MAX_BLOCKS)
-    .map((block, index) => sbNormalizeBlock(block, index, warnings))
-    .filter((block) => block !== null);
-
-  if (rawBlocks.length > MAX_BLOCKS) {
-    warnings.push(`Only the first ${MAX_BLOCKS} storyboard blocks are shown.`);
-  }
-
-  // An empty block list is a valid storyboard: a cover or closing slide whose
-  // layout carries the text itself has no content blocks. Rejecting it dropped
-  // the slide from concept generation — and shifted the server's slideCount so
-  // the LAST slide fell off the request list too.
-  if (rawBlocks.length > 0 && blocks.length === 0) {
-    warnings.push("No storyboard block was valid; the canvas is empty.");
-  }
-
   const keyMessage = sbAsTrimmedString(parsed.keyMessage, SB_MAX_KEY_MESSAGE_LENGTH);
-  const visualFamily = sbAsTrimmedString(
-    parsed.visualFamily,
-    SB_MAX_VISUAL_FAMILY_LENGTH,
-  );
+  const continues = Math.round(sbAsFiniteNumber(parsed.continues, 0));
   const layout = sbAsTrimmedString(parsed.layout, SB_MAX_LAYOUT_NAME_LENGTH);
   const selectionFields = {};
   if (parsed.role === "body" || parsed.role === "frame") selectionFields.role = parsed.role;
@@ -179,24 +89,54 @@ export function parseStoryboardCanvas(raw) {
   const rawContentNotes = Array.isArray(parsed.contentNotes)
     ? parsed.contentNotes
     : parsed.depthNotes;
+  // The slide's content is never shortened here: every concept prompt and
+  // worker brief reads it from this parse, and a cut note reached the image
+  // model mid-word (x80–x87: 195 of 606 notes were over the old 220 cap).
   const contentNotes = Array.isArray(rawContentNotes)
     ? rawContentNotes
-        .slice(0, SB_MAX_DEPTH_NOTES)
-        .map((note) => sbAsTrimmedString(note, SB_MAX_DEPTH_NOTE_LENGTH))
+        .map((note) => (typeof note === "string" ? note.trim() : ""))
         .filter(Boolean)
     : undefined;
+  // The slide's full content draft, written from the approved key points after
+  // sign-off: concept generation and authoring build from it.
+  const content = Array.isArray(parsed.content)
+    ? parsed.content
+        .map((line) => (typeof line === "string" ? line.trim() : ""))
+        .filter(Boolean)
+    : undefined;
+
+  // The one field normalization may NOT touch. Everything else in this parser
+  // is defensive — plan.md is human-edited, so an unreadable field is dropped
+  // and the record still opens. An image use is an APPROVED OBLIGATION: a
+  // malformed one has to surface as an error, because dropping it is exactly
+  // how a picture the user asked for disappears between the plan and the .pptx
+  // (implementation-guide §1). The contract's own strict parser decides;
+  // this module adds no image rule of its own.
+  const uses = validateSlideUses(parsed.assetUses, { slide });
+  if (!uses.value) {
+    return {
+      data: null,
+      warnings,
+      error: uses.issues[0]?.message ?? "assetUses could not be read.",
+      issues: uses.issues,
+    };
+  }
 
   return {
     data: {
       version: 1,
       slide,
-      blocks,
-      ...(visualFamily ? { visualFamily } : {}),
+      ...(continues >= 1 && continues < slide ? { continues } : {}),
       ...(layout ? { layout } : {}),
     ...selectionFields,
       ...(keyMessage ? { keyMessage } : {}),
       ...(contentNotes?.length ? { contentNotes } : {}),
+      ...(content?.length ? { content } : {}),
       ...(Object.keys(imagePrompts).length > 0 ? { imagePrompts } : {}),
+      // Empty means "no uses", which is the absence of the key — a slide that
+      // must CLEAR an obligation does it through the targeted-edit override
+      // file, not through an empty array in the plan.
+      ...(uses.value.length ? { assetUses: uses.value } : {}),
     },
     warnings,
   };

package/src/builders/text-blocks.mjs

@@ -0,0 +1,212 @@
+// The reader marks texts that read as ONE unit with a shared `block` id — a
+// title and the description under it, or the pieces of one sentence painted
+// in two styles ("under **21** days"). Such a block becomes one text element
+// whose members are its `paragraphs`: the transcriber writes one box whose
+// paragraphs stack in flow on the design's own line-height (the image only
+// places the block), settle fits and moves it as one unit, and the export
+// ships one text frame. Every paragraph keeps its role, weight and paint.
+// Pieces set side by side on one line are ONE paragraph: the piece with the
+// most words gives it its style and every piece painted otherwise is a styled
+// `run` of it (an accent figure, a bold term) — x109 GTM 4 shipped a scorecard
+// sentence as five boxes with gaps between them, and x107–x109 left 8–11 such
+// blocks per run as separate texts. A sentence the reader broke at a run and
+// at its wraps is joined again across those lines: a line of pieces and the
+// line before or after it in the same style are one paragraph.
+// A list item is a paragraph with `marker` (concept-lists.mjs): a title over
+// its items is one block, written as one text box whose items are one native
+// list. A block stays as its separate texts only when it cannot be written as
+// one — a member a line glues to, rotated or self-painted text, members in
+// different containers, pieces set apart by a gutter (a name and its value in
+// two columns) — and the fold says so in a note: one sentence is never
+// silently left in several boxes.
+import { recordBlockDividers } from "./block-dividers.mjs";
+
+export const PARAGRAPH_KEYS = ["kind", "x", "text", "role", "weight", "color", "colorHex", "colorToken", "ground", "groundHex", "align", "leadIn", "emphasis", "runs", "marker", "markerToken", "markerHex"];
+
+// Pieces of one line further apart than this many line heights are two
+// columns (a depot name and its share, 118 px apart), not one sentence (the
+// gaps the reader measures between the pieces of a sentence: 2–16 px).
+const RUN_GAP_LINES = 1.5;
+
+const lineHeight = (m) => m.h / Math.max(1, String(m.text).split("\n").length);
+const style = (m) => JSON.stringify([m.role ?? (m.kind === "number" ? "number" : null), m.weight ?? null, m.colorToken ?? null, m.colorHex ?? null, m.color ?? null]);
+const paragraphOf = (m) => Object.fromEntries([["id", m.id], ...PARAGRAPH_KEYS.filter((k) => m[k] != null).map((k) => [k, m[k]])]);
+const flatText = (t) => String(t).replace(/\s*\n\s*/g, " ").trim();
+// No space after a lone opening mark, none before closing punctuation.
+const joinText = (a, b) => (!a ? b : !b ? a : /^[(\[“‘"'«]$/.test(a.trim()) || /^[.,;:!?%)\]”’»]/.test(b) ? `${a}${b}` : `${a} ${b}`);
+// The next painted line of the same sentence: an indented line continues the
+// paragraph (concept-text.mjs textLines), and the break keeps it from being
+// written as one unwrappable line.
+const joinLines = (a, b) => (/^[.,;:!?%)\]”’»]/.test(b) ? `${a}${b}` : `${a}\n ${b}`);
+
+/**
+ * The block's members in reading order: rows top to bottom (a member whose
+ * middle lies within a row's band sits on that row), each row left to right.
+ * The reader declared the block; this only orders what it named.
+ */
+export function readingRows(members) {
+  const rows = [];
+  for (const m of [...members].sort((a, b) => a.y - b.y || a.x - b.x)) {
+    const row = rows.at(-1);
+    const mid = m.y + m.h / 2;
+    if (row && mid >= Math.min(...row.map((r) => r.y)) && mid <= Math.max(...row.map((r) => r.y + r.h))) row.push(m);
+    else rows.push([m]);
+  }
+  return rows.map((row) => row.sort((a, b) => a.x - b.x));
+}
+
+/** Why these rows cannot be one text element, or null. */
+function rowsProblem(rows) {
+  for (const row of rows) {
+    for (let i = 1; i < row.length; i++) {
+      const a = row[i - 1];
+      const b = row[i];
+      const gap = b.x - (a.x + a.w);
+      if (gap > RUN_GAP_LINES * Math.max(lineHeight(a), lineHeight(b))) return "its pieces on one line are set apart by a gutter, two columns rather than one sentence";
+      if (gap < -0.5 * Math.min(lineHeight(a), lineHeight(b))) return "two of its pieces are painted over each other";
+    }
+    if (row.length > 1 && row.some((m) => m.marker || m.paragraphs)) return "a list item shares its line with other pieces";
+  }
+  const extent = (row) => [Math.min(...row.map((m) => m.x)), Math.max(...row.map((m) => m.x + m.w))];
+  for (let i = 1; i < rows.length; i++) {
+    const [a0, a1] = extent(rows[i - 1]);
+    const [b0, b1] = extent(rows[i]);
+    if (!(b0 < a1 && a0 < b1)) return "its lines do not stack in one column";
+  }
+  return null;
+}
+
+const bounds = (ms) => {
+  const x = Math.min(...ms.map((m) => m.x));
+  const y = Math.min(...ms.map((m) => m.y));
+  return { x, y, w: Math.max(...ms.map((m) => m.x + m.w)) - x, h: Math.max(...ms.map((m) => m.y + m.h)) - y };
+};
+
+/** One unit per row: its paragraphs, its box, and the style a neighbouring line must share to continue it. */
+function rowUnit(row) {
+  if (row.length === 1) {
+    const [m] = row;
+    return { ...bounds(row), paras: m.paragraphs ?? [paragraphOf(m)], style: m.paragraphs ? null : style(m), pieces: false };
+  }
+  // The piece with the most words styles the paragraph; every other style is a run.
+  const base = row.reduce((best, m) => (flatText(m.text).length > flatText(best.text).length ? m : best));
+  const runs = row.filter((m) => style(m) !== style(base)).map((m) => Object.fromEntries(
+    Object.entries({ text: flatText(m.text), kind: m.kind, role: m.role, weight: m.weight, color: m.color, colorHex: m.colorHex, colorToken: m.colorToken }).filter(([, v]) => v != null),
+  ));
+  const para = { ...paragraphOf(base), x: row[0].x, text: row.reduce((t, m) => joinText(t, String(m.text).trim()), "") };
+  if (base !== row[0]) delete para.leadIn;
+  if (runs.length) para.runs = runs;
+  return { ...bounds(row), paras: [para], style: style(base), pieces: true };
+}
+
+const WORDS = new Set(["text", "number"]);
+
+/**
+ * The indent a paragraph of `block` is written with, off the block's left
+ * edge: only structure, never alignment. A centred or right-aligned line has
+ * no left edge of its own — its painted x is where its width put it — so an
+ * indent would only shift the axis it is centred on (x110 GTM 3: "412" set
+ * `algn=ctr` with a 33 pt `marL`, off its tile's centre, which users had to
+ * undo by hand; 33–57 such paragraphs per run from x107 on). A list keeps its
+ * words' offset: the marker hangs in it. A plain left line keeps its offset
+ * only where a drawing of the same container ends in the strip it clears — the
+ * disc or icon a title stands beside; any other offset is the painting's noise
+ * and the line starts at the block's edge.
+ */
+export function paragraphIndent(para, block, elements) {
+  const offset = Math.round((para.x ?? block.x) - block.x);
+  if (offset <= 1 || (para.align ?? "left") !== "left") return 0;
+  if (para.marker) return offset;
+  const clears = elements.some((d) => d.parent === block.parent && d.id !== block.id && !WORDS.has(d.kind)
+    && d.x + d.w > block.x - 1 && d.x + d.w <= block.x + offset + 2
+    && d.y < block.y + block.h && d.y + d.h > block.y);
+  return clears ? offset : 0;
+}
+
+/** A line of pieces and the line before or after it in the same style are one paragraph. */
+function joinSentences(units) {
+  const out = [];
+  for (const u of units) {
+    const prev = out.at(-1);
+    const a = prev?.paras.length === 1 ? prev.paras[0] : null;
+    const b = u.paras.length === 1 ? u.paras[0] : null;
+    if (a && b && prev.style && prev.style === u.style && (prev.pieces || u.pieces) && !a.marker && !b.marker) {
+      a.text = joinLines(String(a.text).trim(), String(b.text).trim());
+      const runs = [...(a.runs ?? []), ...(b.runs ?? [])];
+      if (runs.length) a.runs = runs;
+      const emphasis = [...(a.emphasis ?? []), ...(b.emphasis ?? [])];
+      if (emphasis.length) a.emphasis = emphasis;
+      Object.assign(prev, bounds([prev, u]), { pieces: true });
+      continue;
+    }
+    out.push(u);
+  }
+  return out;
+}
+
+export function foldTextBlocks(elements, { connectors = [], notes = null } = {}) {
+  const referenced = new Set(connectors.flatMap((c) => [c.from, c.to]));
+  for (const e of elements) {
+    for (const end of [e.strokeEnds?.start, e.strokeEnds?.end]) if (end?.element) referenced.add(end.element);
+  }
+  const parents = new Set(elements.map((e) => e.parent).filter(Boolean));
+  const writable = (e) => (e.kind === "text" || e.kind === "number") && e.text != null
+    && !e.textRotation && !(e.fill && e.fill !== "none") && !referenced.has(e.id) && !parents.has(e.id);
+  const blocks = new Map();
+  for (const e of elements) {
+    if (!e.block) continue;
+    if (!blocks.has(e.block)) blocks.set(e.block, []);
+    blocks.get(e.block).push(e);
+  }
+  const ids = new Set(elements.map((e) => e.id));
+  const replace = new Map();
+  for (const [block, members] of blocks) {
+    if (members.length < 2) continue;
+    const rows = readingRows(members);
+    const problem = !members.every(writable) ? "a member is a line's end, a container, rotated or painted"
+      : !members.every((c) => c.parent === members[0].parent) ? "its members sit in different containers"
+      : rowsProblem(rows);
+    if (problem) {
+      notes?.push(`text block ${block} kept as ${members.length} texts — ${problem}`);
+      continue;
+    }
+    let id = block;
+    while (ids.has(id)) id = `${id}-text`;
+    ids.add(id);
+    const units = joinSentences(rows.map(rowUnit));
+    const paragraphs = units.flatMap((u) => u.paras);
+    const box = bounds(members);
+    const aligns = new Set(members.map((c) => c.align ?? "left"));
+    const first = rows[0][0];
+    // The box's own style: its first member's, or the paragraph its first line of pieces makes.
+    const lead = rows[0].length === 1 ? first : paragraphs[0];
+    const folded = {
+      id,
+      kind: "text",
+      parent: first.parent ?? null,
+      ...box,
+      text: paragraphs.map((p) => String(p.text)).join("\n"),
+      textSource: "visible",
+      role: lead.role ?? null,
+      weight: lead.weight ?? null,
+      color: lead.color ?? null,
+      colorHex: lead.colorHex ?? null,
+      colorToken: lead.colorToken ?? null,
+      align: aligns.size === 1 ? [...aligns][0] : "left",
+      // One seat for the block where its members agree (seat.mjs).
+      ...(first.seat && members.every((c) => JSON.stringify(c.seat ?? null) === JSON.stringify(first.seat)) ? { seat: first.seat } : {}),
+      // A member that is already a block of its own (a list read as one
+      // element) brings its paragraphs along.
+      paragraphs,
+    };
+    if ("ground" in first) folded.ground = first.ground;
+    if ("groundHex" in first) folded.groundHex = first.groundHex;
+    // A rule drawn between two of the lines rides with that paragraph boundary (block-dividers.mjs).
+    const dividers = recordBlockDividers(units, connectors, (u) => u.paras.length);
+    if (dividers.length) folded.dividers = dividers;
+    replace.set(first.id, folded);
+    for (const c of members) if (c !== first) replace.set(c.id, null);
+  }
+  if (!replace.size) return elements;
+  return elements.flatMap((e) => (replace.has(e.id) ? (replace.get(e.id) ? [replace.get(e.id)] : []) : [e]));
+}