slidemind 0.3.20 → 0.4.1

package/src/builders/settle.mjs

@@ -0,0 +1,1448 @@
+// Settle a transcribed slide against its own render — the machine closing the
+// geometry loop the agent used to close by hand (x27–x30: 4–20 view-draft
+// rounds per deck, most of them "move this text down", "give that card room",
+// "this runs past the slot"). Pure: takes the spec and the measured boxes of
+// one capture, returns an adjusted spec plus the changes it made. The caller
+// re-renders and calls again until nothing changes (a few passes at most).
+//
+// Rules, in order, each in slot pixels:
+//   1. escape  — a text whose measured bottom passes its painted parent's
+//                bottom grows the parent by the overflow (plus a 4px margin)
+//                and pushes every element below the parent down by the same.
+//   2. overlap — two texts that share pixels: the lower one moves down by the
+//                overlap (plus 2px), and so does everything below it inside
+//                the same parent.
+//   3. slot    — anything past the slot's bottom: lift it if there is room
+//                above it.
+// Type size is never changed here: it is the role's rung on the design's ramp
+// (transcribe.mjs), and a text that still does not fit is the author's call.
+import { translateElement } from "./concept-geometry.mjs";
+import { fixedAspect } from "./concept-layout.mjs";
+import { contains, parsePointRef, sanitizeTrace, segmentHitsRect, traceLength } from "./line-fit.mjs";
+import { connectorGeometry, nodePreset, nodeSites, resolveGlued, NATIVE_TOL } from "./line-native.mjs";
+import { readLines } from "./concept-lines.mjs";
+import { correspond, linePoints, lineRows, lineSpans, repeatGroups } from "./repeat-groups.mjs";
+import { textLines } from "./concept-text.mjs";
+import { stackEnv, stackUnder, stacksAlone } from "./text-stack.mjs";
+import { shiftSeparator } from "./rule-shift.mjs";
+import { applyStacks, rowExtent } from "./stack.mjs";
+import { placeBlockDividers } from "./block-dividers.mjs";
+
+export { pathDistance } from "./line-fit.mjs";
+const EPS = 1.5;
+// PowerPoint sets the same Arial a few percent wider than Chrome, so a frame
+// at exactly the Chrome ink breaks its widest word there ("IMPLICATIO|N",
+// dev run 7c5fe730). An unbreakable line keeps this much room. Calibration
+// knob: raise it if package renders still break words the draft keeps whole.
+const PPT_WRAP_SLACK = 0.04;
+const MIN_RULE_PX = 24; // an ornament rule shorter than this reads as a dash
+
+// A connector directive's own box is a stand-in (a few px at its frame's
+// origin), not the line: a free one measures as the span of its two ends; one
+// glued to a node is solved from the source (connectorPaths), never measured
+// from that box. x114 PM 2: the set fold read the stand-in as each card's rule
+// and folded the cards it paints inside, so the rule ran over their discs.
+function connectorExtent(c) {
+  const a = c.fromNode ? null : c.fromPoint;
+  const b = c.toNode ? null : c.toPoint;
+  if (!Number.isFinite(a?.x) || !Number.isFinite(b?.x)) return null;
+  const x = Math.min(a.x, b.x), y = Math.min(a.y, b.y);
+  return { x, y, w: Math.abs(b.x - a.x), h: Math.abs(b.y - a.y) };
+}
+
+export function measuredFromRender(render, slot) {
+  const roots = render?.boxes ?? [];
+  // The content slot is the first root box (the layout's content area); every
+  // rect below is expressed relative to it.
+  const origin = roots[0]?.rect ?? { x: 0, y: 0 };
+  const out = new Map();
+  // A text block (transcribe.mjs `P`, a flowed `L`'s items) measures as its
+  // paragraphs together: the block's box holds no text of its own.
+  const paragraphMetrics = (b) => {
+    const paras = (b.children ?? []).flatMap((c) => (c.elementId ? [] : c.textMetrics ? [c] : (c.children ?? []).filter((li) => !li.elementId && li.textMetrics)));
+    if (b.textMetrics || b.textRuns?.length || !paras.length) return null;
+    return {
+      lineCount: paras.reduce((n, c) => n + (c.textMetrics.lineCount ?? 0), 0),
+      paraLines: paras.map((c) => c.textMetrics.lineCount ?? 0),
+      maxLineW: Math.max(...paras.map((c) => c.textMetrics.maxLineW ?? 0)),
+      maxWordW: Math.max(...paras.map((c) => c.textMetrics.maxWordW ?? 0)),
+      rects: paras.flatMap((c) => c.textMetrics.rects ?? []),
+      // One box per paragraph (slot px): where a divider between two of them belongs (block-dividers.mjs).
+      paraRects: paras.map((c) => ({ y: c.rect.y - origin.y, h: c.rect.h })),
+      sizePx: paras[0].style?.font?.sizePx,
+    };
+  };
+  const walk = (b) => {
+    if (!b || typeof b !== "object") return;
+    const rect = b.connector?.kind === "connector" ? connectorExtent(b.connector) : b.rect;
+    if (b.elementId && rect) {
+      const block = paragraphMetrics(b);
+      const tm = b.textMetrics ?? block;
+      const sizePx = block ? block.sizePx : b.style?.font?.sizePx;
+      out.set(b.elementId, {
+        x: rect.x - origin.x,
+        y: rect.y - origin.y,
+        w: rect.w,
+        h: rect.h,
+        lines: tm?.lineCount ?? null,
+        ...(tm?.paraLines ? { paraLines: tm.paraLines } : {}),
+        ...(tm?.paraRects ? { paraRects: tm.paraRects } : {}),
+        text: Boolean(b.textRuns?.length || tm),
+        ...(b.imgSrc || b.chart ? { content: true } : {}),
+        ...(b.style?.bgColor && (b.style.bgColorAlpha ?? 1) > 0 ? { painted: true } : {}),
+        ...(Number.isFinite(tm?.maxLineW) ? { inkWidth: tm.maxLineW } : {}),
+        ...(tm?.maxWordW > 0 ? { wordWidth: tm.maxWordW } : {}),
+        // A list's marker indent: its words set in the width left of it (word-fit-check.ts).
+        ...(b.style?.padding?.l + b.style?.padding?.r > 0 ? { padX: b.style.padding.l + b.style.padding.r } : {}),
+        ...(tm?.rects?.length ? { inkY: Math.min(...tm.rects.map((r) => r.y)) - origin.y, inkHeight: Math.max(...tm.rects.map((r) => r.y + r.h)) - Math.min(...tm.rects.map((r) => r.y)) } : {}),
+        // Each rendered line's ink (slot px): whether a rule runs through the
+        // words or beside them is a question of lines, not of the text's box.
+        ...(tm?.rects?.length ? { lineRects: tm.rects.map((r) => ({ x: r.x - origin.x, y: r.y - origin.y, w: r.w, h: r.h })) } : {}),
+        ...(Number.isFinite(sizePx) ? { renderedFontPx: sizePx } : {}),
+      });
+    }
+    for (const c of b.children ?? []) walk(c);
+  };
+  for (const r of roots) walk(r);
+  return out;
+}
+
+/**
+ * The lines a text keeps whatever its width: textLines' breaks (a lower-case
+ * continuation flows), counted per paragraph of a folded block — joined, a
+ * paragraph opening lower-case read as a wrap of the one before.
+ */
+export const hardLineCount = (e) => (e.paragraphs?.length ? e.paragraphs.reduce((n, p) => n + textLines(p.text ?? "").length, 0) : textLines(e.text ?? "").length);
+
+const PAINTED = new Set(["card", "panel", "badge", "shape", "disc", "bar"]);
+const isText = (e) => (e.kind === "text" || e.kind === "number") && e.text != null && !e.textRotation;
+const bottom = (r) => r.y + r.h;
+const intersects = (a, b) => a.x < b.x + b.w - EPS && b.x < a.x + a.w - EPS && a.y < bottom(b) - EPS && b.y < bottom(a) - EPS;
+
+/**
+ * The room a text owns in the image: from its own position to the nearest
+ * unrelated element beside / below it, its painted container's edge, or the
+ * slot. Overflowing into empty space is harmless; into a neighbour or out of
+ * its shape it is not.
+ */
+export function textRoom(s, e, { slot = s.slot, gap = 4, byId = new Map(s.elements.map((o) => [o.id, o])) } = {}) {
+  const related = (a, b) => a.id === b.parent || b.id === a.parent || descendsFromIn(byId, a, b.id) || descendsFromIn(byId, b, a.id);
+  const parent = e.parent ? byId.get(e.parent) : null;
+  const box = parent && parent.fill && parent.fill !== "none" ? parent : { x: 0, y: 0, w: slot.w, h: slot.h };
+  let right = box.x + box.w, left = box.x, below = box.y + box.h, above = box.y, under = null;
+  for (const o of s.elements) {
+    if (o === e || related(e, o) || !(o.w > 0 && o.h > 0)) continue;
+    const rowsOverlap = o.y < e.y + e.h && o.y + o.h > e.y;
+    if (rowsOverlap && o.x >= e.x + e.w - 1) right = Math.min(right, o.x - gap);
+    if (rowsOverlap && o.x + o.w <= e.x + 1) left = Math.max(left, o.x + o.w + gap);
+    const colsOverlap = o.x < e.x + e.w && o.x + o.w > e.x;
+    if (colsOverlap && o.y >= e.y + e.h - 1 && o.y - gap < below) [below, under] = [o.y - gap, o];
+    if (colsOverlap && o.y + o.h <= e.y + 1) above = Math.max(above, o.y + o.h + gap);
+  }
+  // A line in its rows is a neighbour too (a loop, the rule beside a title),
+  // and one in its columns a floor or a ceiling (the rule over a title).
+  let rule = null;
+  const own = new Set(s.elements.filter((o) => o === e || related(e, o)).map((o) => o.id));
+  for (const l of lineSpans(s, e.y, e.y + e.h, own)) {
+    if (l.x >= e.x + e.w - 1) {
+      if (l.x - gap < right) [right, rule] = [l.x - gap, l.line];
+    } else if (l.x + l.w <= e.x + 1) left = Math.max(left, l.x + l.w + gap);
+  }
+  for (const l of lineRows(s, e.x, e.x + e.w, own)) {
+    if (l.y >= e.y + e.h - 1 && l.y - gap < below) [below, under] = [l.y - gap, null];
+    else if (l.y + l.h <= e.y + 1) above = Math.max(above, l.y + l.h + gap);
+  }
+  const centred = e.align === "center";
+  const w = centred ? e.w + 2 * Math.max(0, Math.min(e.x - left, right - e.x - e.w)) : (e.align === "right" ? e.x + e.w - left : right - e.x);
+  return { w: Math.max(e.w, w), h: Math.max(e.h, below - e.y), up: Math.max(0, e.y - above), under, rule, edge: box.x + box.w };
+}
+
+/**
+ * Settle a transcribed slide against the image it was read from. Geometry is
+ * the image's; the type is the design's ramp, never a size read off the image,
+ * and where the image broke its lines is no target either. A text whose
+ * rendered ink is wider than its box widens into the free room beside it; one
+ * that still does not fit is left for the author. Returns the adjusted spec
+ * and one line per change.
+ */
+export function fitTextToImage(spec, measured, { slot = spec.slot, gap = 4, last = false } = {}) {
+  const s = JSON.parse(JSON.stringify(spec));
+  const byId = new Map(s.elements.map((e) => [e.id, e]));
+  const changes = [];
+  // The texts re-wrapped here: their measured height is stale until the next render.
+  const stale = new Set();
+  const related = (a, b) => a.id === b.parent || b.id === a.parent || descendsFromIn(byId, a, b.id) || descendsFromIn(byId, b, a.id);
+  const room = (e) => textRoom(s, e, { slot, gap, byId });
+  // A free level rule after a left-set line (a title's "——") is an ornament
+  // that fills the row: it starts after the ink instead, while at least
+  // MIN_RULE_PX of it is left (gtm-03 "4. Handoff rule ——" at the ramp size).
+  const giveWay = (c, from) => {
+    const pts = linePoints(c);
+    const ys = pts.map((p) => p.y);
+    if (c.from || c.to || Math.max(...ys) - Math.min(...ys) > 1) return null;
+    const x = Math.ceil(from + (Number.isFinite(c.strokeWidth) ? c.strokeWidth : 1) / 2);
+    const x0 = Math.min(...pts.map((p) => p.x));
+    if (Math.max(...pts.map((p) => p.x)) - x < MIN_RULE_PX) return null;
+    for (const p of pts) if (p.x <= x0 + 0.5) p.x = x;
+    return x;
+  };
+  const widen = (e, w, why) => {
+    if (e.align === "center") e.x = Math.round((e.x - (w - e.w) / 2) * 10) / 10;
+    else if (e.align === "right") e.x = Math.round((e.x - (w - e.w)) * 10) / 10;
+    changes.push(`${e.id}: width ${Math.round(e.w)}→${Math.round(w)}px ${why}`);
+    e.w = w;
+    stale.add(e.id);
+  };
+  for (const e of s.elements) {
+    if (!isText(e) || !(e.w > 0 && e.h > 0)) continue;
+    const m = measured.get(e.id);
+    if (!(m?.inkWidth > 0)) continue;
+    const r = room(e);
+    // The box holds the ink it renders. Chrome lets a word overflow a narrow
+    // box unbroken, but the box becomes the PPTX frame, and a frame narrower
+    // than a word breaks the word ("Exception|s", x67 cloud 6; 529 texts on
+    // the replay corpus). It grows into the room beside it, anchored by its
+    // alignment.
+    // A line that does not wrap (one line, or only the image's own breaks)
+    // and a word wider than its box are unbreakable: they keep the room
+    // PowerPoint needs. A wrapping paragraph re-wraps instead. The breaks the
+    // slide keeps are textLines' (a lower-case continuation flows); counting
+    // every `\n` took a 4-line paragraph for four unbreakable lines and
+    // widened it again on every pass as it re-wrapped (pm-03 team-body).
+    const hardLines = hardLineCount(e);
+    const unbroken = m.lines != null && m.lines <= hardLines;
+    // A wrapping paragraph needs its widest word (dom-serialiser maxWordW)
+    // with that room; without the measure, a line wider than its box is one.
+    const word = m.wordWidth ?? (m.inkWidth > e.w + 0.25 ? m.inkWidth : 0);
+    if (!unbroken && !(word > 0)) continue;
+    const pad = m.padX ?? 0;
+    const need = Math.ceil((unbroken ? m.inkWidth : word) * (1 + PPT_WRAP_SLACK)) + pad;
+    if (need <= e.w) continue;
+    let w = Math.min(Math.floor(r.w), need);
+    const leftSet = e.align !== "center" && e.align !== "right";
+    const moved = w < need && unbroken && r.rule && leftSet ? giveWay(r.rule, e.x + need + gap) : null;
+    if (moved != null) {
+      changes.push(`${r.rule.id}: starts at ${moved}px, after ${e.id}`);
+      w = Math.min(Math.floor(room(e).w), need);
+    } else if (w < need && unbroken && r.rule && leftSet) {
+      // A separator beside it moves into its gutter (rule-shift.mjs): at least
+      // clear of the ink, as far as PowerPoint's slack where the gutter allows.
+      const dx = shiftSeparator(s, e, (t) => {
+        const mt = measured.get(t.id);
+        const rt = room(t);
+        if (!(mt?.inkWidth > 0) || !rt.rule) return null;
+        const ink = Math.ceil(mt.inkWidth) + (mt.padX ?? 0);
+        return { rule: rt.rule, right: rt.edge, to: t.x + Math.ceil(mt.inkWidth * (1 + PPT_WRAP_SLACK)) + (mt.padX ?? 0) + gap, least: t.x + ink + gap,
+          beside: (o) => o !== t && !related(t, o), holds: () => room(t).w >= ink };
+      }, gap);
+      if (dx) {
+        changes.push(`${r.rule.id}: ${dx}px right, clear of ${e.id}`);
+        w = Math.min(Math.floor(room(e).w), need);
+      }
+    }
+    if (w > e.w) widen(e, w, "to hold its ink");
+    // A line whose ink the room cannot hold — its neighbour, often a rule
+    // beside it, is nearer than its ink is long — wraps inside its box instead
+    // of running over it: `wrap` makes transcribe drop `nowrap` — only where
+    // the lines it gains have room: free rows below it; else, alone in its
+    // column, the room about its own centre (live 6bb93436: a title beside a
+    // divider on a one-row band); else the stack under it moving down by the
+    // rest (text-stack.mjs, on the next render). Wrapped onto a body that
+    // cannot move, a title trades a crossing for text on text (cloud-02).
+    // Missing only PowerPoint's slack is no reason to wrap; one word cannot,
+    // and a text with the image's own breaks already wraps (no nowrap).
+    const lineH = (m.h ?? e.h) / Math.max(1, m.lines ?? 1);
+    if (m.inkWidth > w - pad + 0.5 && unbroken && !e.wrap && !String(e.text).includes("\n") && /\S\s+\S/.test(String(e.text).trim())) {
+      const r2 = room(e);
+      const H = Math.ceil(m.inkWidth / (w - pad)) * lineH;
+      let dy = 0;
+      let fits = H <= r2.h;
+      if (!fits && !r2.under && H <= r2.h + r2.up) {
+        fits = true;
+        const cy = (m.y ?? e.y) + (m.h ?? e.h) / 2;
+        dy = Math.round(Math.min(Math.max(cy - H / 2, e.y - r2.up), e.y + r2.h - H) - e.y);
+      } else if (!fits && r2.under && !last && stacksAlone(s, e)) {
+        const under = stackUnder(stackEnv(s, measured, slot), e, { force: true, want: H - r2.h });
+        fits = under?.first === r2.under && H - r2.h <= under.room;
+      }
+      if (fits) {
+        e.wrap = true;
+        stale.add(e.id);
+        if (dy) translateElement(e, 0, dy);
+        changes.push(`${e.id}: wraps inside its ${Math.round(e.w)}px box (its line is ${Math.ceil(m.inkWidth)}px)${dy ? `, ${dy}px to keep its centre` : ""}`);
+      }
+    }
+  }
+  // A declared set keeps one inner layout (repeat-groups.mjs): a text widened
+  // in one member widens its counterparts alike, where each has the room.
+  for (const g of repeatGroups(s)) {
+    const kids = correspond(s.elements, g.members);
+    for (const [k, first] of (kids?.[0] ?? []).entries()) {
+      if (!isText(first)) continue;
+      const col = kids.map((l) => l[k]);
+      const w = Math.max(...col.map((e) => e.w));
+      if (col.every((e) => e.w === w) || col.some((e) => room(e).w < w)) continue;
+      for (const e of col) if (e.w < w) widen(e, w, `with its set ${g.id}`);
+    }
+  }
+  return { spec: s, changes, stale };
+}
+
+export function settleSpec(spec, measured, { slot = spec.slot } = {}) {
+  const s = JSON.parse(JSON.stringify(spec));
+  const byId = new Map(s.elements.map((e) => [e.id, e]));
+  const changes = [];
+  // The free width beside a text at its rows: the edge of its painted parent
+  // (or the slot) and the nearest element either side of it.
+  const freeSpan = (e, h) => {
+    const top = e.y, bot = e.y + h;
+    const parent = e.parent ? byId.get(e.parent) : null;
+    let right = parent && PAINTED.has(parent.kind) ? parent.x + parent.w - 8 : slot.w;
+    let left = parent && PAINTED.has(parent.kind) ? parent.x + 8 : 0;
+    for (const o of s.elements) {
+      if (o === e || o.id === e.parent || descendsFromIn(byId, o, e.id) || descendsFromIn(byId, e, o.id)) continue;
+      if (o.y >= bot - EPS || o.y + o.h <= top + EPS) continue;
+      if (o.x >= e.x + e.w - EPS) right = Math.min(right, o.x - 4);
+      if (o.x + o.w <= e.x + EPS) left = Math.max(left, o.x + o.w + 4);
+    }
+    return { left, right };
+  };
+  // A nowrap line can overflow while its CSS box still fits perfectly. Use
+  // the capture's actual ink width and widen into free space; a line with no
+  // room beside it stays as it is for the author (the size is the ramp's).
+  for (const e of s.elements) {
+    const m = measured.get(e.id);
+    if (!isText(e) || !(e.w > 0) || !(m?.inkWidth > e.w + EPS)) continue;
+    const { left, right } = freeSpan(e, m.h ?? e.h);
+    const need = Math.ceil(m.inkWidth + 2);
+    const centred = e.align === "center";
+    const grow = need - e.w;
+    if (centred ? e.x - grow / 2 >= left && e.x + e.w + grow / 2 <= right : e.x + need <= right) {
+      if (centred) e.x = Math.round((e.x - grow / 2) * 10) / 10;
+      changes.push(`${e.id}: width ${Math.round(e.w)}→${need}px to hold its line`);
+      e.w = need;
+    }
+  }
+  const rectOf = (e) => {
+    const m = measured.get(e.id);
+    // A text's measured height is the truth; its declared rect is the plan.
+    return m ? { x: e.x, y: e.y, w: Math.max(e.w, isText(e) ? Math.min(m.w, e.w) : e.w), h: isText(e) ? m.h : e.h } : { x: e.x, y: e.y, w: e.w, h: e.h };
+  };
+  // `except` (and its subtree) stays put: the element we are moving things BELOW
+  // may itself sit at `fromY`, and without this it rides down with them. Returns
+  // how many moved, so a caller never records a change that nothing made.
+  const shiftBelow = (fromY, dy, within = null, except = null) => {
+    let moved = 0;
+    for (const el of s.elements) {
+      if (el.y + EPS < fromY) continue;
+      if (within && !(el.parent === within.id || el.id === within.id || descendsFrom(el, within.id))) continue;
+      if (except && (el.id === except.id || descendsFrom(el, except.id))) continue;
+      translateElement(el, 0, dy);
+      moved++;
+    }
+    return moved;
+  };
+  const descendsFrom = (el, id) => {
+    let p = el.parent ? byId.get(el.parent) : null;
+    let guard = 0;
+    while (p && guard++ < 32) {
+      if (p.id === id) return true;
+      p = p.parent ? byId.get(p.parent) : null;
+    }
+    return false;
+  };
+
+  // 0b. clear — a text block may not lie on a painted shape it does not
+  // belong to (x58 cloud 1: the reader put three labels 14px inside their
+  // node's circle). The whole column the text belongs to — texts sharing
+  // its left edge and stacked on it — moves by the smallest shift that
+  // clears the shape, so a title, its body and its label stay aligned.
+  const PAINTS = new Set(["disc", "badge", "card", "panel", "shape"]);
+  const movedCols = new Set();
+  for (const t of s.elements.filter(isText)) {
+    if (movedCols.has(t.id)) continue;
+    const rt = rectOf(t);
+    for (const p of s.elements) {
+      if (!PAINTS.has(p.kind) || !p.fill || p.fill === "none" || p === t) continue;
+      if (descendsFrom(t, p.id) || contains(p, rt) || contains(rt, p)) continue;
+      if (!intersects(rt, p)) continue;
+      const tcx = rt.x + rt.w / 2, pcx = p.x + p.w / 2;
+      const beside = tcx > p.x + p.w || tcx < p.x || Math.abs(tcx - pcx) > p.w / 2;
+      if (!beside) continue;
+      const dx = tcx >= pcx ? p.x + p.w + 6 - rt.x : p.x - 6 - (rt.x + rt.w);
+      if (Math.abs(dx) > Math.max(24, p.w * 0.5)) continue;
+      const column = s.elements.filter((o) => isText(o) && Math.abs(o.x - t.x) <= 3 && o.parent === t.parent
+        && o.y < rt.y + rt.h + 80 && o.y + (measured.get(o.id)?.h ?? o.h) > rt.y - 80);
+      // Never out of the slot: a column that cannot clear the shape inside
+      // it stays, and the overlap is left for the draft check to name.
+      if (column.some((o) => o.x + dx < 0 || o.x + dx + Math.max(o.w, measured.get(o.id)?.w ?? 0) > slot.w)) continue;
+      for (const o of column) {
+        translateElement(o, dx, 0);
+        movedCols.add(o.id);
+      }
+      changes.push(`${column.map((o) => o.id).join(", ")}: ${dx > 0 ? "+" : ""}${Math.round(dx)}px clear of ${p.id}`);
+      break;
+    }
+  }
+  // 1. escape
+  for (const e of s.elements) {
+    if (!isText(e) || !e.parent) continue;
+    const parent = byId.get(e.parent);
+    if (!parent || !PAINTED.has(parent.kind)) continue;
+    const r = rectOf(e);
+    const over = bottom(r) + 4 - bottom(parent);
+    if (over > EPS) {
+      // Geometry is meaning here: stretching a circle into an oval or a
+      // path away from its neighbours is not text fitting. The measured
+      // escape remains for the author to repair.
+      if (fixedAspect(parent)) continue;
+      const oldBottom = bottom(parent);
+      parent.h += over;
+      // Everything that started at or below the parent's old bottom edge,
+      // outside the parent, moves down with it.
+      for (const el of s.elements) {
+        if (el === parent || descendsFrom(el, parent.id)) continue;
+        if (el.y + EPS >= oldBottom && el.x < parent.x + parent.w && parent.x < el.x + el.w) translateElement(el, 0, over);
+      }
+      changes.push(`${parent.id}: +${Math.round(over)}px for ${e.id}`);
+    }
+  }
+  // 2. overlap between texts
+  const texts = s.elements.filter(isText);
+  for (let i = 0; i < texts.length; i++) {
+    for (let j = 0; j < texts.length; j++) {
+      if (i === j) continue;
+      const a = texts[i];
+      const b = texts[j];
+      if (a.y > b.y || (a.y === b.y && i > j)) continue; // b is the lower one
+      const ra = rectOf(a);
+      const rb = rectOf(b);
+      if (!intersects(ra, rb)) continue;
+      const dy = bottom(ra) - rb.y + 2;
+      if (dy <= EPS) continue;
+      const scope = b.parent ? byId.get(b.parent) : null;
+      // Two texts sharing a top edge: `a` is at `fromY` too, so it used to be
+      // shifted along with `b` — both moved by dy, still exactly as overlapped,
+      // one "change" recorded per pass, walking the pair toward the slot edge
+      // until rule 3 shrank their fonts. `a` is held.
+      if (!shiftBelow(b.y, dy, scope, a)) continue;
+      changes.push(`${b.id}: +${Math.round(dy)}px below ${a.id}`);
+      // A shifted text may now escape its parent — rule 1 on the next pass.
+    }
+  }
+  // 3. slot bottom
+  for (const e of s.elements) {
+    if (e.textRotation) continue;
+    const r = rectOf(e);
+    const over = bottom(r) - slot.h;
+    if (over <= EPS) continue;
+    const parent = e.parent ? byId.get(e.parent) : null;
+    const group = parent ? s.elements.filter((x) => x === parent || descendsFrom(x, parent.id)) : [e];
+    const top = Math.min(...group.map((x) => x.y));
+    if (top - over >= 0 && !parent) {
+      for (const x of group) translateElement(x, 0, -over);
+      changes.push(`${e.id}: lifted ${Math.round(over)}px`);
+    } else if (parent && parent.y - over >= 0) {
+      for (const x of group) translateElement(x, 0, -over);
+      changes.push(`${parent.id}: lifted ${Math.round(over)}px`);
+    }
+  }
+  return { spec: s, changes };
+}
+
+function descendsFromIn(byId, el, id) {
+  let p = el.parent ? byId.get(el.parent) : null;
+  let guard = 0;
+  while (p && guard++ < 32) {
+    if (p.id === id) return true;
+    p = p.parent ? byId.get(p.parent) : null;
+  }
+  return false;
+}
+
+// ---- A hand-edited slide: read the transcribed helpers back, settle, rewrite.
+// The transcribed JSX is regular (one `<B|T|I|R … />` per line with literal
+// numbers), so its own output is the only JSX ever parsed here.
+// `</B>` closes a folded card and a chart wrapper, and a chart placeholder line
+// carries a trailing `{/* … */}`: without both, those lines matched nothing and
+// the boxes were missing from `painted`, so containment parented their children
+// onto the wrong box (or onto none).
+const ELEMENT_RE = /^(\s*)<(B|T|I|L)\s+([^\n]*?)(?:\/>|>([^\n]*?)<\/(?:T|L|B)>)\s*(?:\{\/\*[^\n]*\*\/\})?\s*$/;
+const ATTR_RE = /([A-Za-z]+)=(?:\{([^}]*)\}|"([^"]*)")|\b(nowrap|bold|shadow|ordered)\b/g;
+
+export function parseTranscribedJsx(src) {
+  const elements = [];
+  const lines = String(src).split("\n");
+  lines.forEach((line, index) => {
+    const m = ELEMENT_RE.exec(line);
+    if (!m) return;
+    const attrs = {};
+    for (const a of m[3].matchAll(ATTR_RE)) {
+      if (a[4]) attrs[a[4]] = true;
+      else attrs[a[1]] = a[2] != null ? (Number.isFinite(Number(a[2])) ? Number(a[2]) : a[2]) : a[3];
+    }
+    if (!attrs.id) return;
+    const kind = { B: attrs.fill && attrs.fill !== "none" ? "card" : "shape", T: "text", I: "icon", L: "text" }[m[2]];
+    elements.push({
+      ...(typeof attrs.stack === "string" ? { stack: attrs.stack } : {}),
+      line: index,
+      tag: m[2],
+      id: attrs.id,
+      kind,
+      x: attrs.x ?? 0,
+      y: attrs.y ?? 0,
+      w: attrs.w ?? 0,
+      h: attrs.h ?? (m[2] === "T" || m[2] === "L" ? 14 : 0),
+      fill: attrs.fill ?? "none",
+      shape: attrs.shape ?? null,
+      textRotation: attrs.rotation ?? null,
+      text: m[2] === "T" || m[2] === "L" ? (m[4] ?? "").replace(/<[^>]+>/g, " ").trim() : null,
+      parent: null,
+    });
+  });
+  // Parents by containment: the smallest painted box whose rect holds the
+  // element's centre (the JSX is flat; the spec's tree is gone).
+  const painted = elements.filter((e) => e.tag === "B" && e.w > 0 && e.h > 0);
+  for (const e of elements) {
+    const cx = e.x + e.w / 2;
+    const cy = e.y + e.h / 2;
+    let best = null;
+    for (const p of painted) {
+      if (p === e || cx < p.x || cx > p.x + p.w || cy < p.y || cy > p.y + p.h) continue;
+      if (!best || p.w * p.h < best.w * best.h) best = p;
+    }
+    e.parent = best ? best.id : null;
+  }
+  // The declared stacks the lines carry (`stack="n:r"` on a part, "n:gr" on
+  // what is drawn in the gap under row r; STACKS for align and spacing), so a
+  // repair re-lays a row as one unit instead of accepting one moved part.
+  const connectors = lines.map(parseConnectorLine).filter(Boolean);
+  const stacks = stacksFromMarks(src, elements, connectors);
+  const grids = gridsFromMarks(src, connectors);
+  // A divider marked `data-sm-divides="block:after:frac"` belongs to the boundary
+  // between two paragraphs of that block (block-dividers.mjs).
+  const byId = new Map(elements.map((e) => [e.id, e]));
+  for (const c of connectors) {
+    const m = c?.divides && /^(.+):(\d+):([\d.]+)$/.exec(c.divides);
+    const block = m && byId.get(m[1]);
+    if (!block) continue;
+    block.dividers = [...(block.dividers ?? []), { id: c.id, after: Number(m[2]), frac: Number(m[3]) }];
+    block.paragraphs ??= [];
+  }
+  return { elements, connectors: [], stacks, grids, lineMarks: connectors.filter((c) => c.stack || c.divides) };
+}
+
+/** The grids a slide's GRIDS constant and "G<k>:g<r>:<f>" marks describe (stack ids as `stack-<n>`). */
+export function gridsFromMarks(src, connectors = []) {
+  let declared = {};
+  try { declared = JSON.parse(GRIDS_RE.exec(String(src))?.[1] ?? "{}"); } catch { declared = {}; }
+  return Object.entries(declared).map(([k, g]) => ({
+    id: `grid-${k}`,
+    stacks: (g.stacks ?? []).map((n) => `stack-${n}`),
+    rows: g.rows,
+    gapMarks: connectors.filter((c) => c?.id && typeof c.stack === "string" && c.stack.startsWith(`G${k}:g`)).map((c) => {
+      const m = /^G\d+:g(\d+)(?::([\d.]+))?$/.exec(c.stack);
+      return m ? { id: c.id, gap: Number(m[1]) - 1, frac: m[2] != null ? Number(m[2]) : 0.5 } : null;
+    }).filter(Boolean),
+  })).filter((g) => g.stacks.length >= 2 && g.rows >= 2);
+}
+
+const STACKS_RE = /^\s*const STACKS = (\{.*\});\s*$/m;
+const GRIDS_RE = /^\s*const GRIDS = (\{.*\});\s*$/m;
+
+/** The stacks a transcribed slide's marks describe (see parseTranscribedJsx). */
+export function stacksFromMarks(src, elements, connectors = []) {
+  let declared = {};
+  try { declared = JSON.parse(STACKS_RE.exec(String(src))?.[1] ?? "{}"); } catch { declared = {}; }
+  const groups = new Map();
+  const mark = (id, raw, line) => {
+    const m = /^(\d+):(g?)(\d+)(?::([\d.]+))?$/.exec(String(raw ?? ""));
+    if (!m) return;
+    const g = groups.get(m[1]) ?? { id: `stack-${m[1]}`, rows: new Map(), between: [] };
+    if (m[2]) g.between.push({ id, line, gap: Number(m[3]) - 1, ...(m[4] != null ? { frac: Number(m[4]) } : {}) });
+    else g.rows.set(Number(m[3]), [...(g.rows.get(Number(m[3])) ?? []), id]);
+    groups.set(m[1], g);
+  };
+  for (const e of elements) if (e.stack) mark(e.id, e.stack, false);
+  for (const c of connectors) if (c?.stack && c.id) mark(c.id, c.stack, true);
+  const byId = new Map(elements.map((e) => [e.id, e]));
+  const out = [];
+  for (const [n, g] of groups) {
+    const rows = [...g.rows.entries()].sort((a, b) => a[0] - b[0]).map(([, ids]) => ids);
+    if (rows.length < 2) continue;
+    const parents = new Set(rows.flat().map((id) => byId.get(id)?.parent ?? null));
+    const parent = parents.size === 1 ? [...parents][0] : null;
+    const d = declared[n] ?? {};
+    // Spacing on a repaired slide is always as drawn: the band's bounds (the
+    // header above the rows, the divider under them) are not in the marks, so an
+    // even redistribution could only be guessed. Rows and gaps keep their
+    // places; the rows themselves are re-laid as units.
+    out.push({ id: g.id, parent, rows, align: d.align ?? "middle", spacing: "drawn", gapMarks: g.between });
+  }
+  return out;
+}
+
+// Write the settled x/y/h back onto the lines they came from; every other
+// character of the file stays as the editor left it.
+export function applySettledToJsx(src, parsed, settled) {
+  const lines = String(src).split("\n");
+  const byId = new Map(settled.elements.map((e) => [e.id, e]));
+  for (const orig of parsed.elements) {
+    const e = byId.get(orig.id);
+    if (!e) continue;
+    let line = lines[orig.line];
+    const put = (name, value) => {
+      const re = new RegExp(`\\b${name}=\\{[^}]*\\}`);
+      if (re.test(line)) line = line.replace(re, `${name}={${value}}`);
+      else if (value != null) line = line.replace(/^(\s*<[BTIL]\s+id="[^"]*")/, `$1 ${name}={${value}}`);
+    };
+    if (e.x !== orig.x) put("x", Math.round(e.x));
+    if (e.y !== orig.y) put("y", Math.round(e.y));
+    // A `<T>` / `<L>` takes no `h`: text takes the height it needs.
+    const sizedText = orig.tag === "T" || orig.tag === "L";
+    if (!sizedText && e.h !== orig.h) put("h", Math.round(e.h));
+    lines[orig.line] = line;
+  }
+  return lines.join("\n");
+}
+
+export function settleJsx(src, measured, opts = {}) {
+  const parsed = parseTranscribedJsx(src);
+  if (!parsed.elements.length) return { src, changes: [] };
+  // A declared stack first: its rows laid out again from the marks the lines
+  // carry, on the measured heights, every part of a row together — an edit
+  // that moved one part (the gate's "move #x 4px up") is answered by the row.
+  const { spec: stacked, changes: stackChanges, lineMoves } = relayStacks(src, parsed, measured, opts);
+  const { spec: settled, changes: settleChanges } = settleSpec({ elements: stacked.elements, connectors: [], slot: opts.slot }, measured, opts);
+  const changes = [...stackChanges, ...settleChanges];
+  if (!changes.length) return { src, changes };
+  let out = applySettledToJsx(src, parsed, settled);
+  for (const [index, dy] of lineMoves) out = moveLiteralLine(out, index, dy);
+  return { src: out, changes };
+}
+
+// Stacks on the parsed slide: the free lines drawn in the gaps are moved by the
+// same amount as their marks ask, written back as literal point refs.
+function relayStacks(src, parsed, measured, opts) {
+  const lineMoves = new Map();
+  if (!parsed.stacks?.length && !parsed.elements.some((e) => e.dividers)) return { spec: { elements: parsed.elements }, changes: [], lineMoves };
+  const spec = { elements: parsed.elements.map((e) => ({ ...e })), connectors: [], slot: opts.slot, stacks: (parsed.stacks ?? []).map((g) => ({ ...g })), grids: (parsed.grids ?? []).map((g) => ({ ...g })) };
+  // The lines drawn in a gap, as the connectors stack.mjs moves (`points`).
+  for (const c of parsed.lineMarks ?? []) {
+    const pts = [c.fromEnd.point, c.toEnd.point].filter((p) => p && Number.isFinite(p.x) && Number.isFinite(p.y));
+    if (pts.length !== 2) continue;
+    spec.connectors.push({ id: c.id, from: null, to: null, fromPoint: { ...pts[0] }, toPoint: { ...pts[1] }, points: pts.map((p) => ({ ...p })), line: c.line });
+  }
+  // Recorded structure from the marks: the band's gap items are the marked lines
+  // and elements, at their current fraction of the gap (nothing re-inferred).
+  const at = (o) => { const m = measured.get(o.id); return m && m.h > 0 ? { x: o.x, y: m.y ?? o.y, w: o.w, h: m.h } : o; };
+  const byId = new Map(spec.elements.map((e) => [e.id, e]));
+  for (const g of spec.stacks) {
+    const rows = g.rows.map((row) => row.map((id) => byId.get(id)).filter(Boolean)).filter((r) => r.length);
+    if (rows.length < 2) continue;
+    // A row's extent as stack.mjs reads it: its parts AND the lines listed with it.
+    const ext = g.rows.map((row) => { const x = rowExtent(spec, row, at); return x ? [x.top, x.bottom] : [0, 0]; });
+    const between = [];
+    for (const it of g.gapMarks ?? []) {
+      const [a, b] = [ext[it.gap]?.[1], ext[it.gap + 1]?.[0]];
+      if (a == null || b == null) continue;
+      const c = spec.connectors.find((x) => x.id === it.id);
+      const e = byId.get(it.id);
+      const mid = c ? (c.fromPoint.y + c.toPoint.y) / 2 : e ? at(e).y + at(e).h / 2 : null;
+      if (mid == null) continue;
+      // The drawn fraction the mark carries; else where it sits in the gap now.
+      between.push({ id: it.id, line: Boolean(c), gap: it.gap, frac: it.frac ?? (b > a ? Math.min(1, Math.max(0, (mid - a) / (b - a))) : 0.5) });
+    }
+    g.band = { before: [], after: [], sepBefore: null, sepAfter: null, gaps: ext.slice(1).map((r, i) => r[0] - ext[i][1]), lead: 0, lines: {}, between };
+    // The band it owns now: its parent's inner box; its first row stays (drawn lead).
+    const p = g.parent ? byId.get(g.parent) : null;
+    g.band.lead = ext[0][0] - (p ? p.y : 0);
+    delete g.gapMarks;
+  }
+  // A grid's own dividers, at their marked fraction of the shared gap.
+  for (const grid of spec.grids) {
+    grid.band = { between: (grid.gapMarks ?? []).filter((it) => spec.connectors.some((c) => c.id === it.id)).map((it) => ({ ...it, line: true })) };
+    delete grid.gapMarks;
+  }
+  const before = new Map(spec.connectors.map((c) => [c.id, c.fromPoint.y]));
+  const changes = applyStacks(spec, { at });
+  // A block's paragraph count on the repaired slide is what the render shows.
+  for (const e of spec.elements) if (e.dividers && measured.get(e.id)?.paraRects) e.paragraphs = measured.get(e.id).paraRects.map(() => ({}));
+  changes.push(...placeBlockDividers(spec, measured));
+  for (const c of spec.connectors) {
+    const dy = c.fromPoint.y - before.get(c.id);
+    if (dy) lineMoves.set(c.line, dy);
+  }
+  return { spec, changes, lineMoves };
+}
+
+// Move a free line directive's literal point refs by dy.
+function moveLiteralLine(src, index, dy) {
+  const lines = String(src).split("\n");
+  lines[index] = lines[index].replace(/(data-(?:from|to)=")(-?[\d.]+),(-?[\d.]+)"/g, (_, k, x, y) => `${k}${x},${Math.round((Number(y) + dy) * 2) / 2}"`);
+  return lines.join("\n");
+}
+
+
+// ---- Connectors against the whole slide, locally.
+//
+// A connector directive names its preset, adjusts, turn and — for a glued end
+// — the connection site of its node's own preset (the nativeLinesV1 contract).
+// Nodes never move here; a line that crosses a text or picture the concept
+// does not cross is re-solved within its own preset: its adjusts, its turn and
+// (where it pays for itself) a site. What cannot be cleared is reported.
+const CONNECTOR_LINE_RE = /^(\s*)<div data-connector ([^\n]*?)\s*\/>\s*$/;
+
+export function parseConnectorLine(line, index) {
+  const m = CONNECTOR_LINE_RE.exec(line);
+  if (!m) return null;
+  const attrs = {};
+  for (const a of m[2].matchAll(/(?:^|\s)(id|data-[a-z-]+)="([^"]*)"/g)) attrs[a[1].replace(/^data-/, "")] = a[2];
+  if (!attrs.from || !attrs.to) return null;
+  const stack = typeof attrs["sm-stack"] === "string" ? attrs["sm-stack"] : null;
+  const divides = typeof attrs["sm-divides"] === "string" ? attrs["sm-divides"] : null;
+  const end = (ref, site) => (ref.startsWith("#")
+    ? { node: ref.slice(1), site: site != null && /^\d+$/.test(site) ? Number(site) : null }
+    : { point: parsePointRef(ref) });
+  const adj = {};
+  for (const kv of String(attrs.adj ?? "").split(",").filter(Boolean)) {
+    const [k, v] = kv.split(":");
+    if (k && Number.isFinite(Number(v))) adj[k.trim()] = Number(v);
+  }
+  return {
+    line: index,
+    id: attrs.id ?? null,
+    ...(stack ? { stack } : {}),
+    ...(divides ? { divides } : {}),
+    from: attrs.from.replace(/^#/, ""),
+    to: attrs.to.replace(/^#/, ""),
+    fromRef: attrs.from,
+    toRef: attrs.to,
+    fromEnd: end(attrs.from, attrs["from-site"]),
+    toEnd: end(attrs.to, attrs["to-site"]),
+    prst: attrs.prst ?? null,
+    adj,
+    rot: attrs.rot != null ? Number(attrs.rot) : 0,
+    fromSite: attrs["from-site"] ?? null,
+    toSite: attrs["to-site"] ?? null,
+  };
+}
+
+const ROUND_SHAPES = new Set(["circle", "ellipse", "ring"]);
+
+// A node's shape as the SLIDE declares it (the agent may have changed it since
+// the spec was read): an explicit `prst`/`data-prst` (+ adj) or a helper's
+// `shape="…"`. Null when the line names neither.
+function jsxNodeShape(src, id) {
+  const line = String(src ?? "").split("\n").find((l) => l.includes(`id="${id}"`) && !/data-connector\b/.test(l));
+  if (!line) return null;
+  const attr = (k) => new RegExp(`\\s(?:data-)?${k}="([^"]*)"`).exec(line)?.[1] ?? null;
+  const prst = attr("prst");
+  if (prst) {
+    const av = Object.fromEntries((attr("adj") ?? "").split(",").map((kv) => kv.split(":")).filter(([k, v]) => k && Number.isFinite(Number(v))).map(([k, v]) => [k, Number(v)]));
+    return { prst, av };
+  }
+  const shape = attr("shape");
+  return shape ? { kind: "card", shape, fill: "light" } : null;
+}
+
+// The nodes a slide's connectors glue to, as presets over their MEASURED rects
+// — shaped as the slide's own source declares them, the spec only where the
+// source is silent.
+function measuredNodes(connectors, measured, byId = new Map(), src = null) {
+  const nodes = new Map();
+  for (const c of connectors) for (const e of [c.fromEnd, c.toEnd]) {
+    if (!e.node || nodes.has(e.node) || !measured.get(e.node)) continue;
+    const m = measured.get(e.node);
+    const rect = { x: m.x, y: m.y, w: m.w, h: m.h };
+    const own = jsxNodeShape(src, e.node);
+    const n = own?.prst ? { prst: own.prst, av: own.av, box: rect } : nodePreset(own ?? byId.get(e.node) ?? { kind: "card" }, rect);
+    if (n) nodes.set(e.node, n);
+  }
+  return nodes;
+}
+
+// The path a parsed directive draws over the given nodes (null when an end
+// cannot be resolved).
+function drawnPath(c, nodes) {
+  const at = (e) => {
+    if (e.point) return e.point;
+    const node = nodes.get(e.node);
+    return node && e.site != null ? nodeSites(node)[e.site] ?? null : null;
+  };
+  const S = at(c.fromEnd), E = at(c.toEnd);
+  if (!S || !E || !c.prst) return null;
+  return connectorGeometry(c.prst, S, E, c.rot, c.adj)?.points ?? null;
+}
+
+// Write a re-solved connector's sites, turn and adjusts back onto its line.
+function rewriteConnector(line, n) {
+  let out = line;
+  const setAttr = (name, value) => {
+    const re = new RegExp(`\\sdata-${name}="[^"]*"`);
+    if (value == null || value === "") out = out.replace(re, "");
+    else if (re.test(out)) out = out.replace(re, ` data-${name}="${value}"`);
+    else out = out.replace(/ data-prst="/, ` data-${name}="${value}" data-prst="`);
+  };
+  setAttr("from-site", n.from.node ? n.from.site : null);
+  setAttr("to-site", n.to.node ? n.to.site : null);
+  setAttr("rot", n.rot || null);
+  const adj = Object.entries(n.av ?? {}).map(([k, v]) => `${k}:${Math.round(v)}`).join(",");
+  if (/\sdata-adj="/.test(out) || adj) {
+    if (/\sdata-adj="/.test(out)) out = out.replace(/\sdata-adj="[^"]*"/, adj ? ` data-adj="${adj}"` : "");
+    else out = out.replace(/(\sdata-prst="[^"]*")/, `$1 data-adj="${adj}"`);
+  }
+  return out;
+}
+
+/**
+ * Every top-level connector directive of a slide with the path it draws over
+ * the MEASURED nodes (`[{ id, prst, fromEnd, toEnd, points, … }]`) — the
+ * exporter's placement, evaluated by the shared preset evaluator.
+ */
+export function connectorPaths(src, measured, spec = null) {
+  const byId = new Map((spec?.elements ?? []).map((e) => [e.id, e]));
+  const connectors = String(src ?? "").split("\n").map(parseConnectorLine).filter((c) => c?.prst);
+  const nodes = measuredNodes(connectors, measured, byId, src);
+  return connectors.map((c) => ({ ...c, points: drawnPath(c, nodes), fromBox: nodes.get(c.fromEnd.node)?.box ?? null, toBox: nodes.get(c.toEnd.node)?.box ?? null })).filter((c) => c.points);
+}
+
+const obstaclesOf = (measured) => [...measured.entries()].filter(([, m]) => (m.text || m.content || m.painted) && m.w > 0 && m.h > 0).map(([id, m]) => ({ id, ...m }));
+
+/**
+ * Re-solve every glued connector that crosses a text, picture or painted box
+ * (`measured`, slot px) within its own preset. Returns `{ src, changes,
+ * unresolved }`.
+ */
+export function routeConnectors(src, measured, { minGap = 2 } = {}) {
+  const lines = String(src).split("\n");
+  const connectors = lines.map(parseConnectorLine).filter((c) => c && (c.fromEnd.node || c.toEnd.node));
+  if (!connectors.length) return { src, changes: [], unresolved: [] };
+  const nodes = measuredNodes(connectors, measured, new Map(), src);
+  const obstacles = obstaclesOf(measured);
+  const changes = [];
+  const unresolved = [];
+  const crossings = (points, c) => {
+    const own = [c.fromEnd.node, c.toEnd.node].filter(Boolean).map((id) => measured.get(id)).filter(Boolean);
+    const hits = [];
+    for (const t of obstacles) {
+      if (own.some((r) => contains(r, t) || (!t.text && !t.content && contains(t, r)))) continue;
+      const box = { x: t.x - minGap, y: t.y - minGap, w: t.w + 2 * minGap, h: t.h + 2 * minGap };
+      for (let i = 0; i + 1 < points.length; i++) if (segmentHitsRect(points[i], points[i + 1], box)) { hits.push(t.id); break; }
+    }
+    return hits;
+  };
+  for (const c of connectors) {
+    const current = drawnPath(c, nodes);
+    if (!current) {
+      const bad = [c.fromEnd, c.toEnd].filter((e) => e.node && nodes.has(e.node) && !nodeSites(nodes.get(e.node))[e.site]);
+      if (bad.length) unresolved.push(`${c.from} → ${c.to}: ${bad.map((e) => `site ${e.site} does not exist on ${e.node} (${nodes.get(e.node).prst}, sites 0–${nodeSites(nodes.get(e.node)).length - 1})`).join("; ")} — name one of its sites`);
+      continue;
+    }
+    const hits = crossings(current, c);
+    if (!hits.length) continue;
+    const n = resolveGlued({ prst: c.prst, from: c.fromEnd, to: c.toEnd }, nodes, { obstacles, crossPenalty: NATIVE_TOL.routeCrossPenaltyPx });
+    const after = n ? connectorGeometry(n.prst, n.start, n.end, n.rot, n.av)?.points : null;
+    if (!after || crossings(after, c).length) {
+      unresolved.push(`${c.from} → ${c.to} crosses ${hits.join(", ")}; no turn, adjust or site of its ${c.prst} clears it with the nodes where they are — move the text or the node`);
+      continue;
+    }
+    lines[c.line] = rewriteConnector(lines[c.line], n);
+    changes.push(`${c.from} → ${c.to}: ${c.prst} re-solved (sites ${n.from.site ?? "point"}→${n.to.site ?? "point"}${n.rot ? `, rot ${n.rot}` : ""}) clears ${hits.join(", ")}`);
+  }
+  return { src: lines.join("\n"), changes, unresolved };
+}
+
+
+// ---- May the settling core rewrite THIS file? (safeguard-slide-editing 6.1)
+//
+// A ledger entry proves ancestry, not syntax eligibility: `state/transcribed.json`
+// says these bytes were once machine-written, not that they still ARE. So the
+// repair gate re-reads the bytes in front of it every time, BEFORE any mutation,
+// and a node it does not understand fails the whole FILE — it is never skipped
+// while the rest of the slide is rewritten around it. That silent partial
+// rewrite is the bug this exists to prevent.
+//
+// Pure like the rest of this module: no fs, no throw, no write. The caller reads
+// the deck's conversion record (src/lib/conversions.mjs → `loadConversions`) and
+// passes it in; `conversion: undefined` means nobody looked, which is a refusal
+// of its own — missing evidence is unknown, not passed. Converted/native source
+// always refuses: its geometry belongs to the original package, not to us.
+const SLOT_OPEN_RE = /^\s*<div style=\{\{\s*position:\s*"relative",\s*width:\s*(\d+(?:\.\d+)?),\s*height:\s*(\d+(?:\.\d+)?)\s*\}\}>\s*$/;
+const SLOT_CLOSE_RE = /^\s*<\/div>\s*$/;
+const FIGURE_RE = /^\s*<div id="[^"]+"(?: data-sm-plot-owner="[^"]+")? style=\{\{[^{}]*\}\}><svg [^\n]*<\/svg><\/div>\s*$/;
+const COMMENT_RE = /^\s*\{\/\*[^\n]*\*\/\}\s*$/;
+const CONNECTOR_START_RE = /^\s*<div data-connector\b/;
+// A native line shape or a chain group: one self-contained line the settle
+// core never rewrites (its geometry is its own coordinates).
+const LINE_SHAPE_RE = /^\s*<div data-sm-line(?:-group)?\s[^\n]*(?:\/>|<\/div>)\s*$/;
+const HELPER_START_RE = /^\s*<[BTIL]\s/;
+const DIALECT_RE = /^\s*\/\/\s*SLIDEMIND_DIALECT:\s*converted\b/m;
+const NATIVE_RE = /\bdata-sm-(?:native-object|source-id)\b|<ConvertedHost/;
+const NUMBER_RE = /^-?\d+(?:\.\d+)?$/;
+const GEOMETRY_IN_STYLE_RE = /(?:^|[,{\s])(?:left|top|width|height)\s*:/;
+// A `style` is opaque to the rewrite but not to this gate: the transcriber
+// writes a closed vocabulary there — the kit's own maps or a literal —
+// and anything else (a ternary, an identifier, a call) is a value nobody here
+// can evaluate, so the slide's paint is not what the measurement assumed.
+const KIT_REF = String.raw`(?:TONE|FILL|ROLE|RADIUS)(?:\["[^"]*"\]|\.[A-Za-z_$][\w$]*)`;
+const STYLE_ENTRY_RE = new RegExp(
+  String.raw`^(?:\.\.\.${KIT_REF}|[A-Za-z][\w-]*\s*:\s*(?:"[^"]*"|-?\d+(?:\.\d+)?|${KIT_REF}))$`,
+);
+
+// An object literal's top-level entries: commas inside strings, brackets,
+// braces or parens belong to the value, not to the list.
+function styleEntries(text) {
+  const out = [];
+  let depth = 0;
+  let quote = null;
+  let from = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (quote) {
+      if (c === quote && text[i - 1] !== "\\") quote = null;
+    } else if (c === '"' || c === "'" || c === "`") quote = c;
+    else if ("([{".includes(c)) depth++;
+    else if (")]}".includes(c)) depth--;
+    else if (c === "," && depth === 0) {
+      out.push(text.slice(from, i).trim());
+      from = i + 1;
+    }
+  }
+  out.push(text.slice(from).trim());
+  return out.filter(Boolean);
+}
+
+// The props each helper in the transcriber's kit actually destructures; an
+// attribute outside its list is a no-op the author believes in.
+// Every prop the generated helpers take — `stack` (a declared stack's row
+// mark) on all four, `block` (one text, text-blocks.mjs) on T and L.
+const HELPER_ATTRS = {
+  B: ["id", "x", "y", "w", "h", "plotOwner", "prst", "adj", "fill", "fillVar", "shape", "shadow", "align", "valign", "style", "stack"],
+  T: ["id", "x", "y", "w", "h", "valign", "px", "role", "bold", "tone", "colorVar", "align", "nowrap", "rotation", "stack", "block"],
+  L: ["id", "x", "y", "w", "px", "indent", "align", "role", "tone", "colorVar", "bullet", "ordered", "markerVar", "stack", "block"],
+  I: ["id", "x", "y", "w", "h", "src", "use", "fit", "pos", "crop", "view", "stack"],
+};
+const REQUIRED_ATTRS = {
+  B: ["id", "x", "y", "w", "h"],
+  T: ["id", "x", "y", "w"],
+  L: ["id", "x", "y", "w"],
+  I: ["id", "x", "y", "w", "h", "src"],
+};
+// The five the settle pass writes back: a computed one cannot be measured, and
+// rewriting it would replace the author's expression with a number.
+const NUMERIC_ATTRS = new Set(["x", "y", "w", "h", "px", "rotation", "indent"]);
+const FLAG_ATTRS = new Set(["nowrap", "bold", "shadow", "ordered"]);
+
+// One JSX attribute list, left to right: every character must be accounted for.
+// `bad` is the first run this cannot read — a ternary, an identifier, a template
+// literal, an unclosed brace — and the caller turns it into a refusal.
+function scanAttrs(text) {
+  const attrs = new Map();
+  let i = 0;
+  while (i < text.length) {
+    if (/\s/.test(text[i])) {
+      i++;
+      continue;
+    }
+    const rest = text.slice(i);
+    const flag = /^(nowrap|bold|shadow|ordered)(?=\s|$)/.exec(rest);
+    if (flag) {
+      attrs.set(flag[1], { kind: "flag", value: true });
+      i += flag[1].length;
+      continue;
+    }
+    const name = /^([A-Za-z][A-Za-z0-9-]*)=/.exec(rest);
+    if (!name) return { attrs, bad: rest.trim() };
+    i += name[0].length;
+    if (text[i] === '"') {
+      const end = text.indexOf('"', i + 1);
+      if (end < 0) return { attrs, bad: text.slice(i).trim() };
+      attrs.set(name[1], { kind: "string", value: text.slice(i + 1, end) });
+      i = end + 1;
+    } else if (text[i] === "{") {
+      let depth = 0;
+      let j = i;
+      for (; j < text.length; j++) {
+        if (text[j] === "{") depth++;
+        else if (text[j] === "}" && --depth === 0) break;
+      }
+      if (depth !== 0) return { attrs, bad: text.slice(i).trim() };
+      attrs.set(name[1], { kind: "expr", value: text.slice(i + 1, j).trim() });
+      i = j + 1;
+    } else return { attrs, bad: text.slice(i).trim() };
+  }
+  return { attrs, bad: null };
+}
+
+/**
+ * Validate one slide file's CURRENT representation against the generated helper
+ * subset — the only JSX the settling core knows how to rewrite.
+ *
+ * `conversion` is the slide's `conversions/<stem>.json` record as
+ * `loadConversions()` returns it, or `null` when the caller checked and there is
+ * none. Leaving it out is itself a refusal (`provenance_unknown`).
+ *
+ * Returns `{ ok, reasons }`; `reasons` is `[{ code, line, message }]` with a
+ * 1-based line or null. Never throws, never writes, mutates nothing.
+ */
+export function validateSettleTarget(src, { conversion } = {}) {
+  const reasons = [];
+  const add = (code, line, message) => reasons.push({ code, line, message });
+  try {
+    const source = String(src ?? "");
+    if (conversion === undefined) {
+      add("provenance_unknown", null, "no conversion provenance was supplied — read conversions/<stem>.json first and pass `conversion` (null when the slide has no record); missing evidence is unknown, not passed");
+    } else if (conversion) {
+      add("converted_provenance", null, `converted slide (dialect ${conversion.dialect ?? "converted"}): its geometry belongs to the original package, so bounded repair never rewrites it — edit its JSX directly`);
+    }
+    if (DIALECT_RE.test(source) || NATIVE_RE.test(source)) {
+      add("converted_provenance", null, "the source carries converted/native markers (SLIDEMIND_DIALECT, ConvertedHost or data-sm-*) — bounded repair never rewrites converted source");
+    }
+
+    const lines = source.split("\n");
+    const opens = lines.map((l, i) => (SLOT_OPEN_RE.test(l) ? i : -1)).filter((i) => i >= 0);
+    if (!opens.length) {
+      add("no_slot_container", null, 'no slot container: the generated slide holds its elements in one <div style={{ position: "relative", width: N, height: N }}>');
+    }
+    for (const extra of opens.slice(1)) {
+      add("unsupported_node", extra + 1, "a second slot container — the settling core rewrites one slot per slide");
+    }
+    const start = opens.length ? opens[0] : -1;
+    let end = lines.length;
+    if (start >= 0) {
+      end = lines.findIndex((l, i) => i > start && SLOT_CLOSE_RE.test(l));
+      if (end < 0) {
+        end = lines.length;
+        add("no_slot_container", start + 1, "the slot container is never closed on a line of its own");
+      }
+    }
+
+    const ids = new Set();
+    const tagsUsed = new Set();
+    lines.forEach((line, index) => {
+      const at = index + 1;
+      const inside = start >= 0 && index > start && index < end;
+      const elementish = ELEMENT_RE.test(line) || CONNECTOR_START_RE.test(line) || LINE_SHAPE_RE.test(line) || HELPER_START_RE.test(line);
+      if (!inside) {
+        // Outside the slot the core rewrites nothing — but it READS the whole
+        // file line by line, so an element out here would be mutated by a rule
+        // that never saw its context.
+        if (elementish) add("element_outside_slot", at, `an element or connector outside the slot container: ${line.trim().slice(0, 80)}`);
+        return;
+      }
+      if (!line.trim() || COMMENT_RE.test(line) || FIGURE_RE.test(line) || LINE_SHAPE_RE.test(line)) return;
+      if (CONNECTOR_START_RE.test(line)) {
+        const parsed = parseConnectorLine(line, index);
+        // An end is a literal node ref ("#id") or a literal point ("x,y").
+        const end = String.raw`(?:#[^"\s]+|-?\d+(?:\.\d+)?,-?\d+(?:\.\d+)?)`;
+        const literal = new RegExp(String.raw`\sdata-from="${end}"`).test(line) && new RegExp(String.raw`\sdata-to="${end}"`).test(line);
+        if (!parsed || !literal) {
+          add("computed_connector_endpoint", at, "a connector's data-from/data-to must be literal \"#id\" or \"x,y\" strings on one self-closing line — the lint and the router read them statically");
+        }
+        return;
+      }
+      const m = ELEMENT_RE.exec(line);
+      if (!m) {
+        add("unsupported_node", at, `not generated helper syntax: ${line.trim().slice(0, 80)}`);
+        return;
+      }
+      const tag = m[2];
+      tagsUsed.add(tag);
+      const { attrs, bad } = scanAttrs(m[3]);
+      if (bad) {
+        add("unsupported_expression", at, `<${tag}> carries an attribute the reader cannot evaluate: ${bad.slice(0, 60)}`);
+        return;
+      }
+      for (const name of REQUIRED_ATTRS[tag]) {
+        if (!attrs.has(name)) add("missing_attribute", at, `<${tag}> is missing the required ${name}`);
+      }
+      for (const [name, value] of attrs) {
+        if (!HELPER_ATTRS[tag].includes(name)) {
+          add("unsupported_node", at, `<${tag}> takes no ${name} — the helper ignores it, so the file is not the generated one`);
+        } else if (NUMERIC_ATTRS.has(name)) {
+          if (value.kind !== "expr" || !NUMBER_RE.test(value.value)) {
+            add("unsupported_expression", at, `<${tag}> ${name} must be a literal number, not ${value.kind === "string" ? `"${value.value}"` : value.value}`);
+          }
+        } else if (name === "style") {
+          if (value.kind !== "expr" || !value.value.startsWith("{")) add("unsupported_expression", at, `<${tag}> style must be an object literal`);
+          else if (GEOMETRY_IN_STYLE_RE.test(value.value)) add("unsupported_expression", at, `<${tag}> sets left/top/width/height in style — geometry the settle pass cannot see or move`);
+          else for (const entry of styleEntries(value.value.replace(/^\{|\}$/g, ""))) {
+            if (!STYLE_ENTRY_RE.test(entry)) add("unsupported_expression", at, `<${tag}> style carries a computed value: ${entry.slice(0, 60)}`);
+          }
+        } else if (FLAG_ATTRS.has(name)) {
+          if (value.kind !== "flag") add("unsupported_expression", at, `<${tag}> ${name} is a bare flag, not ${name}={…}`);
+        } else if (value.kind !== "string") {
+          add("unsupported_expression", at, `<${tag}> ${name} must be a literal string, not {${value.value.slice(0, 40)}}`);
+        }
+      }
+      const id = attrs.get("id");
+      if (id?.kind === "string") {
+        if (ids.has(id.value)) add("duplicate_element_id", at, `two elements share the id "${id.value}" — the rewrite keys by id and would move the wrong one`);
+        ids.add(id.value);
+      }
+    });
+    for (const tag of tagsUsed) {
+      if (!new RegExp(`const ${tag} = \\(\\{`).test(source)) {
+        add("missing_helper", null, `<${tag}> is used but the file declares no ${tag} helper — its geometry is not the kit's`);
+      }
+    }
+  } catch (err) {
+    add("unsupported_node", null, `the source could not be read as generated helper syntax: ${err?.message ?? err}`);
+  }
+  return { ok: reasons.length === 0, reasons };
+}
+
+
+// ---- The repair budget (safeguard-slide-editing 6.2)
+//
+// What an explicit `repair` operation is allowed to change, and by how much.
+// CONSERVATIVE STARTING LIMITS — not experimentally validated quality claims.
+// They exist so a bounded repair cannot quietly turn into a redesign; widening
+// one is an explicit amendment on the operation record (`target.repairPolicy`),
+// never something targeted-edit escalates into by itself.
+//
+// These are a different kind of number from the verdict module's measurement
+// tolerances (`RENDER_GEOMETRY_TOLERANCE_PX` and friends, src/lib/preservation-
+// verdict.mjs): those say how much noise two renders of the SAME slide may
+// show, these say how far repair may move a slide that really did change.
+export const REPAIR_BUDGET = Object.freeze({
+  /** Mutating passes. A verification render after the last one is not a pass. */
+  maxPasses: 3,
+  /** Slot px an element may travel, CUMULATIVELY over the whole operation. */
+  maxTranslationPx: 8,
+  /** Fraction of the original width/height an element may grow or shrink by. */
+  maxSizeChangeRatio: 0.1,
+  /** Font fitting is off unless the operation explicitly permits it. */
+  allowFontFitting: false,
+  /** With font fitting on: the most a size may drop, cumulatively. */
+  maxFontShrinkPx: 1,
+  /** …and never below the design's own minimum. */
+  minFontPx: 10,
+});
+
+/** How far past the slot a measured rect may sit before it counts as escaped. */
+export const REPAIR_BOUNDS_SLACK_PX = 1;
+
+const POLICY_NUMBERS = ["maxPasses", "maxTranslationPx", "maxSizeChangeRatio", "maxFontShrinkPx", "minFontPx"];
+
+/**
+ * The budget for one operation target: the defaults with that target's
+ * `repairPolicy` overrides applied. Returns `{ policy, errors }` — an override
+ * this build cannot read is an error, never a silently ignored key, because a
+ * policy nobody applied would read as a policy that passed.
+ */
+export function repairPolicyFor(target = null) {
+  const errors = [];
+  const override = target?.repairPolicy ?? null;
+  const policy = { ...REPAIR_BUDGET };
+  if (override != null && (typeof override !== "object" || Array.isArray(override))) {
+    return { policy, errors: [{ code: "invalid_policy", message: "repairPolicy must be an object" }] };
+  }
+  for (const [key, value] of Object.entries(override ?? {})) {
+    if (!(key in REPAIR_BUDGET)) {
+      errors.push({ code: "unknown_policy_key", message: `repairPolicy.${key} is not part of the repair budget (${Object.keys(REPAIR_BUDGET).join(", ")})` });
+      continue;
+    }
+    if (key === "allowFontFitting") {
+      if (typeof value !== "boolean") errors.push({ code: "invalid_policy", message: "repairPolicy.allowFontFitting must be a boolean" });
+      else policy[key] = value;
+      continue;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+      errors.push({ code: "invalid_policy", message: `repairPolicy.${key} must be a non-negative number` });
+      continue;
+    }
+    if (key === "maxPasses" && (!Number.isInteger(value) || value < 1)) {
+      errors.push({ code: "invalid_policy", message: "repairPolicy.maxPasses must be a whole number of at least 1" });
+      continue;
+    }
+    policy[key] = value;
+  }
+  for (const key of POLICY_NUMBERS) if (!Number.isFinite(policy[key])) errors.push({ code: "invalid_policy", message: `repairPolicy.${key} is not a number` });
+  return { policy, errors };
+}
+
+/** The slot the slide's own container declares, or null when it has none. */
+export function readSlot(src) {
+  for (const line of String(src ?? "").split("\n")) {
+    const m = SLOT_OPEN_RE.exec(line);
+    if (m) return { w: Number(m[1]), h: Number(m[2]) };
+  }
+  return null;
+}
+
+// Every helper element and connector of one file, by identity — the shape the
+// before/after comparison needs. Attribute values are raw strings; the caller
+// coerces the five it cares about.
+function inventory(src) {
+  const elements = new Map();
+  const connectors = [];
+  String(src ?? "").split("\n").forEach((line, index) => {
+    const m = ELEMENT_RE.exec(line);
+    if (m) {
+      const { attrs } = scanAttrs(m[3]);
+      const id = attrs.get("id");
+      if (id?.kind !== "string") return;
+      const props = {};
+      for (const [name, value] of attrs) if (name !== "id") props[name] = value.kind === "flag" ? true : value.value;
+      elements.set(id.value, { tag: m[2], line: index, props, text: (m[4] ?? "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim() });
+      return;
+    }
+    const c = parseConnectorLine(line, index);
+    if (c) connectors.push(c);
+  });
+  return { elements, connectors };
+}
+
+const num = (v) => (v == null ? null : Number(v));
+// What repair itself writes back, so a difference here is the engine's own work
+// rather than somebody else's edit. Everything else is compared verbatim.
+const REPAIRED_PROPS = new Set(["x", "y", "h", "px"]);
+const ROUTED_ATTRS = ["prst", "adj", "rot", "fromSite", "toSite"];
+
+/**
+ * The structured diff between the source the operation was prepared against and
+ * a candidate — measured from the ORIGINAL every time. Three passes of "only
+ * 7px" is 21px of drift when each pass is measured against the one before it,
+ * which is exactly the escalation the budget exists to stop.
+ */
+export function repairDelta(originalSrc, candidateSrc) {
+  const before = inventory(originalSrc);
+  const after = inventory(candidateSrc);
+  const elements = [];
+  const added = [...after.elements.keys()].filter((id) => !before.elements.has(id));
+  const removed = [...before.elements.keys()].filter((id) => !after.elements.has(id));
+  for (const [id, a] of before.elements) {
+    const b = after.elements.get(id);
+    if (!b) continue;
+    const props = {};
+    for (const key of new Set([...Object.keys(a.props), ...Object.keys(b.props)])) {
+      if (a.props[key] !== b.props[key]) props[key] = { from: a.props[key] ?? null, to: b.props[key] ?? null };
+    }
+    const dw = (num(b.props.w) ?? 0) - (num(a.props.w) ?? 0);
+    const dh = (num(b.props.h) ?? 0) - (num(a.props.h) ?? 0);
+    elements.push({
+      id,
+      dx: (num(b.props.x) ?? 0) - (num(a.props.x) ?? 0),
+      dy: (num(b.props.y) ?? 0) - (num(a.props.y) ?? 0),
+      dw,
+      dh,
+      w0: num(a.props.w) ?? 0,
+      h0: num(a.props.h) ?? 0,
+      dFontPx: (num(b.props.px) ?? num(a.props.px) ?? 0) - (num(a.props.px) ?? 0),
+      fontPx: num(b.props.px),
+      textChanged: a.text !== b.text,
+      assetChanged: (a.props.src ?? null) !== (b.props.src ?? null),
+      // A property repair never writes: the author's fill, role, tone, align…
+      otherProps: Object.fromEntries(Object.entries(props).filter(([k]) => !REPAIRED_PROPS.has(k) && k !== "src")),
+    });
+  }
+  const endpoints = (inv) => inv.connectors.map((c) => `${c.from}→${c.to}`);
+  const routed = [];
+  if (before.connectors.length === after.connectors.length) {
+    before.connectors.forEach((c, i) => {
+      const d = after.connectors[i];
+      const changed = ROUTED_ATTRS.filter((k) => String(c[k] ?? "") !== String(d[k] ?? ""));
+      if (changed.length) routed.push({ from: d.from, to: d.to, changed });
+    });
+  }
+  return {
+    elements,
+    added,
+    removed,
+    routed,
+    endpointsChanged: endpoints(before).join("|") !== endpoints(after).join("|"),
+  };
+}
+
+/**
+ * The budget read over one slide's delta. Returns one reason per violation —
+ * a rejected candidate names every limit it broke, not just the first.
+ */
+export function budgetViolations(delta, policy = REPAIR_BUDGET, { slide = null } = {}) {
+  const out = [];
+  const add = (code, elementId, message) => out.push({ code, slide, elementId, message });
+  for (const id of delta.added) add("element_added", id, `repair may not add elements; ${id} is new`);
+  for (const id of delta.removed) add("element_removed", id, `repair may not delete elements; ${id} is gone`);
+  if (delta.endpointsChanged) add("endpoint_changed", null, "repair may re-route a connector but never re-point it: the from/to identities changed");
+  for (const r of delta.routed) {
+    if (r.changed.includes("prst")) add("connector_preset_changed", null, `repair re-solves a connector within its own preset; ${r.from} → ${r.to} changed preset`);
+  }
+  for (const e of delta.elements) {
+    if (e.textChanged) add("text_changed", e.id, `repair may not change text; ${e.id} reads differently`);
+    if (e.assetChanged) add("asset_changed", e.id, `repair may not change assets; ${e.id} points at another file`);
+    const travelled = Math.hypot(e.dx, e.dy);
+    if (travelled > policy.maxTranslationPx + 1e-9) {
+      add("translation_exceeded", e.id, `${e.id} moved ${travelled.toFixed(1)}px from its original position; the budget is ${policy.maxTranslationPx}px over the whole operation`);
+    }
+    for (const [axis, d, base] of [["width", e.dw, e.w0], ["height", e.dh, e.h0]]) {
+      const allowed = Math.abs(base) * policy.maxSizeChangeRatio;
+      if (Math.abs(d) > allowed + 1e-9) {
+        add("size_exceeded", e.id, `${e.id} changed ${axis} by ${Math.abs(d).toFixed(1)}px (${base ? Math.round((Math.abs(d) / base) * 100) : "∞"}%); the budget is ${Math.round(policy.maxSizeChangeRatio * 100)}%`);
+      }
+    }
+    if (e.dFontPx !== 0) {
+      if (!policy.allowFontFitting) add("font_changed", e.id, `${e.id}'s font size changed by ${e.dFontPx}px; this operation does not permit font fitting`);
+      else if (e.dFontPx > 0) add("font_changed", e.id, `${e.id}'s font grew by ${e.dFontPx}px; font fitting may only shrink`);
+      else if (-e.dFontPx > policy.maxFontShrinkPx + 1e-9) add("font_changed", e.id, `${e.id}'s font shrank ${-e.dFontPx}px; the budget is ${policy.maxFontShrinkPx}px`);
+      if (e.fontPx != null && e.fontPx < policy.minFontPx) add("font_below_minimum", e.id, `${e.id} would render at ${e.fontPx}px, below the design's minimum of ${policy.minFontPx}px`);
+    }
+    for (const [key, change] of Object.entries(e.otherProps)) {
+      add("undeclared_change", e.id, `${e.id}.${key} changed (${JSON.stringify(change.from)} → ${JSON.stringify(change.to)}); repair writes geometry and connector routing, nothing else`);
+    }
+  }
+  return out;
+}
+
+/** Elements the final render leaves outside their own slot. */
+export function boundsDefects(measured, slot, ids = null) {
+  const out = [];
+  for (const [id, m] of measured) {
+    if (ids && !ids.has(id)) continue;
+    const past = [];
+    if (m.x < -REPAIR_BOUNDS_SLACK_PX) past.push("left");
+    if (m.y < -REPAIR_BOUNDS_SLACK_PX) past.push("top");
+    if (m.x + m.w > slot.w + REPAIR_BOUNDS_SLACK_PX) past.push("right");
+    if (m.y + m.h > slot.h + REPAIR_BOUNDS_SLACK_PX) past.push("bottom");
+    if (past.length) out.push({ code: "bounds_escaped", elementId: id, message: `${id} sits past the slot's ${past.join(" and ")} edge after the final pass` });
+  }
+  return out;
+}
+
+/**
+ * Run the bounded repair passes over a set of slides, in memory.
+ *
+ * `slides` is `[{ key, path, original, policy?, slot? }]`; `render(sources)`
+ * takes `Map<path, src>` and returns `Map<path, measuredMap>` — the caller
+ * writes those sources into its candidate workspace and captures them. Nothing
+ * here touches a disk, so the candidate can be discarded by simply not using
+ * the result.
+ *
+ * The loop always ends on a render that observed the LAST mutation: either a
+ * pass that measured the previous pass's work and found nothing left to do, or
+ * an extra verification render once the pass budget is spent. A pass that
+ * mutates and is never rendered is the bug this ordering exists to prevent.
+ */
+export async function repairPasses({ slides, render, cancelled = () => false }) {
+  if (!slides?.length) return { ok: false, passes: 0, verified: false, slides: [], reasons: [{ code: "no_targets", message: "bounded repair was given no slides to repair" }] };
+  const state = slides.map((s) => ({
+    ...s,
+    policy: s.policy ?? REPAIR_BUDGET,
+    slot: s.slot ?? readSlot(s.original),
+    src: s.original,
+    changes: [],
+    routeChanges: [],
+    unresolved: [],
+  }));
+  // Settling measures against the slot the slide's own container declares; a
+  // source without one has nothing to settle into.
+  const slotless = state.find((s) => !s.slot);
+  if (slotless) return { ok: false, passes: 0, verified: false, slides: [], reasons: [{ code: "no_slot", message: `${slotless.path} declares no content slot (its relative container with width and height); bounded repair settles only transcribed source`, slide: slotless.key }] };
+  const maxPasses = Math.min(...state.map((s) => s.policy.maxPasses));
+  const sources = () => new Map(state.map((s) => [s.path, s.src]));
+  const fail = (code, message, extra = {}) => ({ ok: false, passes, verified, slides: state, reasons: [{ code, message, ...extra }] });
+  let passes = 0;
+  let verified = false;
+  const capture = async () => {
+    try {
+      return { measured: await render(sources()) };
+    } catch (err) {
+      return { error: err };
+    }
+  };
+
+  while (passes < maxPasses) {
+    if (cancelled()) return fail("cancelled", "the repair was cancelled; nothing was published");
+    const { measured, error } = await capture();
+    if (error) return fail("capture_failed", `the candidate could not be rendered: ${error?.message ?? error}`);
+    passes++;
+    let mutated = 0;
+    for (const s of state) {
+      const m = measured.get(s.path) ?? new Map();
+      const settled = settleJsx(s.src, m, { slot: s.slot });
+      if (settled.changes.length) {
+        s.src = settled.src;
+        s.changes.push(...settled.changes);
+        mutated += settled.changes.length;
+        continue;
+      }
+      // Geometry stands: route the connectors against the same measurement.
+      const routed = routeConnectors(s.src, m);
+      s.unresolved = routed.unresolved;
+      if (routed.changes.length) {
+        s.src = routed.src;
+        s.routeChanges.push(...routed.changes);
+        mutated += routed.changes.length;
+      }
+    }
+    // The budget is read from the ORIGINAL after every pass, so drift is caught
+    // on the pass that causes it rather than at the end.
+    const violations = state.flatMap((s) => budgetViolations(repairDelta(s.original, s.src), s.policy, { slide: s.key }));
+    if (violations.length) return { ok: false, passes, verified, slides: state, reasons: violations };
+    if (!mutated) {
+      // This render measured the last mutation and asked for nothing more.
+      verified = true;
+      const escaped = state.flatMap((s) => boundsDefects(measured.get(s.path) ?? new Map(), s.slot, new Set(inventory(s.src).elements.keys())).map((d) => ({ ...d, slide: s.key })));
+      if (escaped.length) return { ok: false, passes, verified, slides: state, reasons: escaped };
+      return { ok: true, passes, verified, slides: state, reasons: [] };
+    }
+  }
+
+  // The pass budget is spent and the last pass mutated: verify that mutation.
+  if (cancelled()) return fail("cancelled", "the repair was cancelled; nothing was published");
+  const { measured, error } = await capture();
+  if (error) return fail("capture_failed", `the repaired candidate could not be verified: ${error?.message ?? error}`);
+  verified = true;
+  const defects = [];
+  for (const s of state) {
+    const m = measured.get(s.path) ?? new Map();
+    const { changes } = settleJsx(s.src, m, { slot: s.slot });
+    for (const c of changes) defects.push({ code: "not_converged", slide: s.key, message: `${maxPasses} passes were not enough: ${c}` });
+    defects.push(...boundsDefects(m, s.slot, new Set(inventory(s.src).elements.keys())).map((d) => ({ ...d, slide: s.key })));
+  }
+  // An unresolved crossing is REPORTED, never fatal: the router has already
+  // established that the only thing left would be moving a node, which is
+  // outside the repair budget by design.
+  if (defects.length) return { ok: false, passes, verified, slides: state, reasons: defects };
+  return { ok: true, passes, verified, slides: state, reasons: [] };
+}
+
+
+// ---- Lines re-solved on the final geometry.
+//
+// Every line was fitted to the concept when the slide was written
+// (line-native.mjs). The render places the nodes where they really are, so a
+// glued connector is solved once more against the MEASURED rects: its preset
+// and its glue stay, its adjusts, turn and sites follow the nodes, scored by
+// its distance from the concept's path plus a penalty per crossing the concept
+// does not have. Nodes never move.
+export function fitConnectors(src, spec, measured) {
+  // `fitted`: one entry per glued line — its preset, glue and distance from
+  // the concept (the line census and the draft notes read it).
+  const result = { src, changes: [], unresolved: [], fitted: [] };
+  if (!spec) return result;
+  const lines = String(src).split("\n");
+  const byId = new Map((spec.elements ?? []).map((e) => [e.id, e]));
+  const traces = new Map(readLines(structuredClone(spec)).lines.map((l) => [l.id, (l.path?.points ?? []).filter((p) => Number.isFinite(p?.x) && Number.isFinite(p?.y))]));
+  const connectors = lines.map(parseConnectorLine).filter((c) => c?.prst && (c.fromEnd.node || c.toEnd.node));
+  const nodes = measuredNodes(connectors, measured, byId, src);
+  const obstacles = obstaclesOf(measured);
+  for (const c of connectors) {
+    const raw = traces.get(c.id);
+    const round = (id) => { const e = byId.get(id); return e?.kind === "disc" || ROUND_SHAPES.has(e?.shape); };
+    const box = (e) => (e.node ? nodes.get(e.node)?.box ?? null : null);
+    const trace = raw?.length >= 2 ? sanitizeTrace(raw, box(c.fromEnd), box(c.toEnd), { fromRound: round(c.fromEnd.node), toRound: round(c.toEnd.node) }) : null;
+    const n = resolveGlued({ prst: c.prst, from: c.fromEnd, to: c.toEnd }, nodes, { trace, obstacles });
+    if (!n) continue;
+    const tolerance = trace ? Math.max(NATIVE_TOL.gluedPx, NATIVE_TOL.gluedFrac * traceLength(trace)) : null;
+    result.fitted.push({ id: c.id, prst: n.prst, glued: Boolean(n.from.node && n.to.node), distance: trace ? n.devPx : null, tolerance });
+    const out = rewriteConnector(lines[c.line], n);
+    if (out === lines[c.line]) continue;
+    lines[c.line] = out;
+    const beyond = trace && n.devPx > tolerance ? ` — ${Math.round(n.devPx)}px from the concept's line, beyond tolerance: the closest this ${n.prst} glued at its nodes' sites can draw it` : "";
+    result.changes.push(`${c.id ?? `${c.from} → ${c.to}`}: ${n.prst} re-solved on the measured nodes (sites ${n.from.site ?? "point"}→${n.to.site ?? "point"}${n.rot ? `, rot ${n.rot}` : ""})${beyond}`);
+  }
+  result.src = lines.join("\n");
+  return result;
+}