slidemind 0.3.20 → 0.4.0

package/src/builders/settle-driver.mjs

@@ -0,0 +1,236 @@
+// The first-write settle, driven the same way by both clients: the CLI's
+// `transcribe` and the add-in's slide preparation run THIS loop and hand in only
+// their renderer and their file access. Mirrored into the add-in by
+// scripts/sync-transcription-runtime.mjs — no Node or CLI imports here.
+import { fitTextToImage, fitConnectors, measuredFromRender } from "./settle.mjs";
+import { fitTextToCard } from "./text-card-fit.mjs";
+import { translateElement, writtenTop } from "./concept-geometry.mjs";
+import { foldSets } from "./fold-sets.mjs";
+import { applyCopyFit, slideContext, textOverruns } from "./copy-fit.mjs";
+import { typeLadder } from "./design-tokens.mjs";
+
+export const SETTLE_PASSES = 4;
+
+/**
+ * The last render's measurements with a pass's changes applied, or null when
+ * that pass needs a new render: a pass that only moved elements and gave cards
+ * new heights leaves every text as it was set (its lines, its ink), so the
+ * next pass can run on the moved rects. A text's width, a wrap, a scaled disc,
+ * anything else changes what a render measures — as does a move the writer
+ * does not make one to one (a text on the slot's floor, writtenTop).
+ */
+export function movedMeasurements(measured, before, after) {
+  if (after.elements.length !== before.elements.length) return null;
+  const slot = after.slot;
+  const was = new Map(before.elements.map((e) => [e.id, e]));
+  const out = new Map(measured);
+  for (const e of after.elements) {
+    const o = was.get(e.id);
+    if (!o) return null;
+    const [dx, dy, dw, dh] = [e.x - o.x, e.y - o.y, e.w - o.w, e.h - o.h];
+    // The element as it was, moved (and, a shape, resized): anything else differs.
+    const text = e.text != null;
+    const as = structuredClone(o);
+    translateElement(as, dx, dy);
+    if (!text) Object.assign(as, { w: e.w, h: e.h });
+    if (JSON.stringify(as, near) !== JSON.stringify(e, near)) return null;
+    if (Math.abs(writtenTop(e, slot) - writtenTop(o, slot) - dy) > 1e-6) return null;
+    const m = measured.get(e.id);
+    if (!m || !(dx || dy || dw || dh)) continue;
+    out.set(e.id, {
+      ...m,
+      x: m.x + dx,
+      y: m.y + dy,
+      ...(Number.isFinite(m.inkY) ? { inkY: m.inkY + dy } : {}),
+      ...(text ? {} : { w: m.w + dw, h: m.h + dh }),
+    });
+  }
+  return out;
+}
+// Moves add up in floats: equal to a micro-pixel.
+const near = (_k, v) => (typeof v === "number" ? Math.round(v * 1e6) / 1e6 : v);
+
+/**
+ * Render the machine-written slides, fit each text's box to the room the image
+ * gives it, rewrite, re-render — until nothing changes or the passes run out. Then fit
+ * every connector once, on the final geometry.
+ *
+ * - `slides`: `[{ key, spec }]` — `spec` is replaced as the passes adjust it.
+ * - `capture(keys)` → `Map<key, render>` (a render carries `boxes`); throw when
+ *   the renderer is unavailable. `null` = no renderer: connectors are fitted
+ *   against the spec's own rectangles.
+ * - `rescaffold(slide, spec)` rewrites that slide's source from the adjusted spec.
+ * - `readSource(key)` / `writeSource(key, src)` for the connector fit and the
+ *   set fold.
+ * - `ramp` (design-tokens.mjs parseTypeRamp): a slide whose text still runs
+ *   past its room moves its whole type ladder one step down, once.
+ * - `fitCopy({ key, items, context, plan })` → `[{ id, text }]`: the words of
+ *   what still does not fit, one call per slide (copy-fit.mjs copyFitPrompt);
+ *   a slide's `plan` is its storyboard beat.
+ */
+function createSession({ capture, rescaffold, readSource, writeSource, ramp = null, fitCopy = null, passes = SETTLE_PASSES, onPass = (_pass, _count) => {}, onError = (_stage, _error) => {} }) {
+  const result = { passes: 0, changes: 0, bySlide: new Map() };
+  const note = (key, lines) => {
+    if (!lines?.length) return;
+    result.bySlide.set(key, [...(result.bySlide.get(key) ?? []), ...lines]);
+  };
+  let rendered = Boolean(capture);
+  // The measurements of a slide's final geometry (a render whose pass changed
+  // nothing): the connector fit reads them instead of capturing the slide again.
+  const finals = new Map();
+  // Each slide's last rendered measurements, final or not.
+  const latest = new Map();
+  const settlePasses = async (list) => {
+    let live = list;
+    for (let pass = 1; pass <= passes && live.length; pass++) {
+      onPass(pass, live.length);
+      let renders;
+      try {
+        renders = await capture(live.map((s) => s.key));
+      } catch (err) {
+        onError("settle", err);
+        if (pass === 1) rendered = false;
+        break;
+      }
+      result.passes = Math.max(result.passes, pass);
+      const next = [];
+      for (const s of live) {
+        const render = renders.get(s.key);
+        if (!render?.boxes) { onError("render", new Error(`${s.key}: no render in settle pass ${pass} — left as written`)); continue; }
+        let measured = measuredFromRender(render, s.spec.slot);
+        latest.set(s.key, measured);
+        const texts = [...measured.values()].filter((m) => m.text);
+        if (texts.length && texts.every((m) => !(m.inkWidth > 0))) onError("render", new Error(`${s.key}: the render carried no text measurements in settle pass ${pass} — its type was not fitted`));
+        // Ink first (a word wider than its frame), then a text past its card
+        // or grown into its stack, in the same pass: the card levers leave
+        // alone what the ink fit just re-wrapped (`stale`), which waits for
+        // the render of this pass; everything else is independent of it. A
+        // pass that only moved things runs again on the moved measurements
+        // (movedMeasurements) instead of waiting for a render; the state it
+        // ends in is predicted, so it gets one render of its own to confirm
+        // it (a moved text wraps or lands differently than predicted) and
+        // never stands as final measurements. A wrap that leaves its stack
+        // to the next render is not made on the last pass (`last`).
+        for (let rigid = 0; ; rigid++) {
+          const ink = fitTextToImage(s.spec, measured, { last: pass === passes });
+          const card = fitTextToCard(ink.spec, measured, { stale: ink.stale });
+          const changes = [...ink.changes, ...card.changes];
+          if (!changes.length) {
+            if (rigid) next.push(s);
+            else finals.set(s.key, measured);
+            break;
+          }
+          const before = s.spec;
+          s.spec = card.spec;
+          result.changes += changes.length;
+          note(s.key, changes);
+          await rescaffold(s, card.spec);
+          const moved = movedMeasurements(measured, before, card.spec);
+          if (!moved) { next.push(s); break; }
+          measured = moved;
+          // Moves that keep answering each other settle nothing a render would.
+          if (rigid + 1 >= passes) { next.push(s); break; }
+        }
+      }
+      live = next;
+    }
+  };
+  const overruns = (s, tighten) => {
+    const measured = finals.get(s.key) ?? latest.get(s.key);
+    return measured ? textOverruns(s.spec, measured, { tighten }) : [];
+  };
+  const rewrite = async (s, spec, lines) => {
+    s.spec = spec;
+    result.changes += lines.length;
+    note(s.key, lines);
+    finals.delete(s.key);
+    await rescaffold(s, spec);
+  };
+  // A slide keeps ONE type hierarchy. Text that still runs past its room
+  // after the fit moves the whole ladder one step down (every text alike,
+  // once); what still does not fit then gets shorter words, never a size.
+  const fitType = async (list) => {
+    const down = typeLadder(ramp, -1);
+    if (down && down.body !== typeLadder(ramp, 0).body) {
+      const tight = list.filter((s) => !s.spec.typeStepOffset && overruns(s).length);
+      for (const s of tight) {
+        const n = overruns(s).length;
+        await rewrite(s, { ...s.spec, typeStepOffset: -1 }, [`type one step down (${down.body} body): ${n} text${n === 1 ? "" : "s"} ran past ${n === 1 ? "its" : "their"} room`]);
+      }
+      await settlePasses(tight);
+    }
+    if (!fitCopy) return;
+    for (const tighten of [1, 0.85]) {
+      const fitted = [];
+      await Promise.all(list.map(async (s) => {
+        const items = overruns(s, tighten).filter((i) => !i.why);
+        if (!items.length) return;
+        try {
+          const answers = await fitCopy({ key: s.key, items, context: slideContext(s.spec), plan: s.plan ?? null });
+          const applied = applyCopyFit(s.spec, items, answers);
+          if (!applied.changes.length) return;
+          await rewrite(s, applied.spec, applied.changes);
+          fitted.push(s);
+        } catch (err) {
+          onError("copy-fit", err);
+        }
+      }));
+      if (!fitted.length) return;
+      await settlePasses(fitted);
+    }
+  };
+  // Lines, once, on the final geometry: every glued connector is re-solved
+  // within its own preset against the measured nodes and the path the image
+  // draws (crossings count against it) — never anything but a native line.
+  const fitConnectorsOn = async (list) => {
+    const linked = list.filter((s) => s.spec?.connectors?.length);
+    if (!linked.length) return;
+    let renders = null;
+    const moved = linked.filter((s) => !finals.has(s.key));
+    if (rendered && moved.length) {
+      try { renders = await capture(moved.map((s) => s.key)); }
+      catch (err) { onError("connectors", err); }
+    }
+    for (const s of linked) {
+      const render = renders?.get(s.key);
+      if (!finals.has(s.key) && render?.boxes) finals.set(s.key, measuredFromRender(render, s.spec.slot));
+      const measured = finals.get(s.key) ?? new Map((s.spec.elements ?? []).map((e) => [e.id, { x: e.x, y: e.y, w: e.w, h: e.h, text: e.text != null, painted: Boolean(e.fill && e.fill !== "none") }]));
+      const src = await readSource(s.key);
+      const fitted = fitConnectors(src, s.spec, measured);
+      if (fitted.src !== src) await writeSource(s.key, fitted.src);
+      s.routeChanges = fitted.changes;
+      s.fitted = fitted.fitted;
+    }
+  };
+  // Last: every built set becomes one local component (fold-sets.mjs). Every
+  // pass before reads and rewrites the flat lines, so this runs after them.
+  const foldSetsOn = async (list) => {
+    for (const s of list) {
+      if (!s.spec?.repeats?.some((g) => g.built)) continue;
+      const src = await readSource(s.key);
+      const folded = foldSets(src, s.spec, finals.get(s.key) ?? latest.get(s.key) ?? null);
+      if (folded.src !== src) await writeSource(s.key, folded.src);
+      s.foldedSets = folded.folded;
+    }
+  };
+  return { result, settlePasses, fitType, fitConnectorsOn, foldSetsOn };
+}
+
+/**
+ * Render the machine-written slides, fit each text's box to the room the image
+ * gives it and inside the card it sits on (its size stays the design's ramp),
+ * rewrite, re-render — until nothing changes or the passes run out. Text that
+ * still does not fit steps the slide's ladder down, then shortens its words.
+ * Then fit every connector once, on the final geometry, and fold each built
+ * set into one component.
+ */
+export async function settleWrittenSlides(opts) {
+  const session = createSession(opts);
+  if (opts.capture) {
+    await session.settlePasses(opts.slides);
+    await session.fitType(opts.slides);
+  }
+  await session.fitConnectorsOn(opts.slides);
+  await session.foldSetsOn(opts.slides);
+  return session.result;
+}