slidemind 0.3.20 → 0.4.0

package/src/builders/text-card-fit.mjs

@@ -0,0 +1,552 @@
+// Fit a transcribed text inside the card the reader put it in. The card's
+// height is the image's, the type is the design's ramp (transcribe.mjs), so a
+// text often wraps into more lines than the image drew and runs out of its
+// card (09-27 agentic loop: four ring cards, 10–26px each). The trigger is
+// measured containment the reader declared (`parent`), never an image line
+// count. One lever per card per pass — the settle driver re-renders between
+// (after a pass that only moved things it applies the moves to the last
+// render instead), and cards apart from each other advance side by side (the
+// driver has four passes; one slide-wide lever per pass starved the last cards
+// of theirs):
+//   1. widen  — the text into its card's free inner width;
+//   1b. rows  — a divider a wrapped text runs through moves down with what is
+//               under it, only where the card then still holds its content
+//               (with its new height, placed in the same pass: both are rigid);
+//   2. disc   — the disc beside it one step smaller, the text takes the width;
+//   3. height — one new height, the content re-anchored in it (a centred text
+//               re-centres, a top-set one lifts to the inset; card-height.mjs).
+// Then (S) a text past the slot's bottom, or past a card none of those could
+// fit, lifts into the free room above it with its stack and its row; a text
+// on no card first widens into the room beside it.
+// Symmetry first: a card the reader declared part of a repeated set
+// (repeat-groups.mjs) never changes alone — every lever acts on every member
+// alike, and a new height is placed by the set's arrangement (a row keeps its
+// line, a column its gaps, a ring grows about its centres and moves or closes
+// in as one). A lone card with undeclared lookalikes keeps its size and disc:
+// resizing it alone would break a symmetry nobody declared, so that fit is
+// the author's. The type size never changes; a circle keeps its shape.
+import { translateElement } from "./concept-geometry.mjs";
+import { fixedAspect } from "./concept-layout.mjs";
+import { linePoints, lineSpans, linesWithin, moveLine } from "./repeat-groups.mjs";
+import { hardLineCount } from "./settle.mjs";
+import { cardHeight } from "./card-height.mjs";
+import { columnOf, declaredSets, inkOf, isCard, isMarker, isRound, looksLike as alike, markerRoom, stackUnder } from "./text-stack.mjs";
+import { seatFrame, seatOf, seatRect } from "./seat.mjs";
+import { applyStacks } from "./stack.mjs";
+import { placeBlockDividers } from "./block-dividers.mjs";
+
+const INSET = 8; // px kept between a text and its card's edge (settle.mjs freeSpan)
+const GAP = 4; // px kept from a neighbour
+const MIN_GAIN = 2; // px of width worth a render pass
+const ESCAPE_PX = 3; // a descender past the edge is no escape (overlap-check.ts)
+const DISC_SCALE = 0.8; // one step, once: a disc is the card's emblem, not padding
+const SLOT_PX = 1; // past the slot's bottom (slot-fit.ts EPSILON_PX)
+const STACK_GAP = 12; // px between a text and the one stacked on it (a title over its body)
+
+const filled = (e) => Boolean(e?.fill && e.fill !== "none");
+// A text box; words ON a painted shape (a number badge) belong to that shape.
+const isText = (e) => (e.kind === "text" || e.kind === "number") && e.text != null && !e.textRotation && !filled(e);
+const span = (a0, a1, b0, b1) => a0 < b1 && b0 < a1;
+const hit = (a, b, gap = 0) => span(a.x, a.x + a.w, b.x, b.x + b.w) && span(a.y - gap, a.y + a.h + gap, b.y, b.y + b.h);
+
+export function fitTextToCard(spec, measured, { slot = spec.slot, stale = new Set() } = {}) {
+  const s = JSON.parse(JSON.stringify(spec));
+  const byId = new Map(s.elements.map((e) => [e.id, e]));
+  const changes = [];
+  const kids = (el) => s.elements.filter((o) => o.parent === el.id);
+  const subtree = (el) => [el, ...kids(el).flatMap(subtree)];
+  const inTree = (el, root) => {
+    for (let p = el, guard = 0; p && guard < 32; p = p.parent ? byId.get(p.parent) : null, guard++) if (p === root) return true;
+    return false;
+  };
+  // Where a text really is: its measured rect (the image's height is a plan),
+  // plus what this call moved it by — a rigid move needs no new render.
+  const shift = new Map();
+  const at = (t) => {
+    const m = measured.get(t.id);
+    return m?.h > 0 ? { y: m.y != null ? m.y + (shift.get(t.id) ?? 0) : t.y, h: m.h } : { y: t.y, h: t.h };
+  };
+  const move = (o, dy) => {
+    translateElement(o, 0, dy);
+    shift.set(o.id, (shift.get(o.id) ?? 0) + dy);
+  };
+  const heightOf = (o) => (isText(o) ? at(o).h : o.h);
+  // What the ink fit re-wrapped in this pass (`stale`) is measured wrong until
+  // the next render: nothing here acts on it or on the card it sits on.
+  const isStale = (el) => subtree(el).some((o) => stale.has(o.id));
+  const img0 = new Map(s.elements.map((e) => [e.id, { x: e.x, y: e.y, w: e.w, h: e.h }]));
+  const env = { s, byId, measured, slot, at, img: (o) => img0.get(o.id) ?? o, isText, filled, subtree, inTree };
+  const textsOf = (card) => kids(card).filter(isText).sort((a, b) => a.y - b.y || a.x - b.x);
+  const block = (card) => {
+    const ts = textsOf(card);
+    if (!ts.length) return null;
+    return { texts: ts, top: Math.min(...ts.map((t) => at(t).y)), bottom: Math.max(...ts.map((t) => at(t).y + at(t).h)) };
+  };
+  const pastOf = (card) => (block(card)?.bottom ?? -Infinity) - (card.y + card.h);
+
+  const declared = declaredSets(s);
+  const unitOf = (card) => declared.find((g) => g.members.includes(card)) ?? { id: null, members: [card], arrangement: null, hub: null };
+  // Symmetry nobody declared is still symmetry: a lone card that looks like
+  // its neighbours is never resized on its own (text-stack.mjs looksLike).
+  const looksLike = (o, card) => alike(s, o, card);
+  const lookalike = (card) => s.elements.some((o) => looksLike(o, card));
+  // A divider on the card that a text above it runs through (a title that
+  // wrapped into a second line at the design's type size): px to push it down.
+  // A divider between two paragraphs of one block is placed by its block (0c),
+  // never pushed under the whole block as "a line the text runs through".
+  const blockDividers = new Set(s.elements.flatMap((e) => (e.dividers ?? []).map((d) => d.id)));
+  const crossingOf = (card) => {
+    let best = null;
+    for (const c of linesWithin(s, card)) {
+      if (c.id && blockDividers.has(c.id)) continue;
+      const ys = linePoints(c).map((p) => p.y);
+      if (Math.max(...ys) - Math.min(...ys) > 2) continue;
+      const ly = ys.reduce((a, b) => a + b, 0) / ys.length;
+      const xs = linePoints(c).map((p) => p.x);
+      for (const t of textsOf(card)) {
+        const r = at(t);
+        const need = Math.ceil(r.y + r.h + GAP - ly);
+        if (!span(t.x, t.x + t.w, Math.min(...xs), Math.max(...xs))) continue;
+        // Measured lines decide: a rule runs through a text only where it
+        // crosses one of its lines' ink. A rule on a line's row but past its
+        // words is beside them — "Early Signal Review ———" (x113 PM 3): the
+        // block's frame is as wide as its body, and the average line height
+        // of a tall title over small body lines put the rule "in" the text,
+        // so it was pushed under the whole block.
+        const m = measured.get(t.id);
+        if (m?.lineRects?.length) {
+          const dy = r.y - (m.y ?? r.y);
+          const dx = t.x - (m.x ?? t.x);
+          const hit = m.lineRects.some((l) => ly > l.y + dy + 1 && ly < l.y + dy + l.h - 1 && span(l.x + dx, l.x + dx + l.w, Math.min(...xs), Math.max(...xs)));
+          if (hit && (!best || need > best.need)) best = { need, y: ly };
+          continue;
+        }
+        // A rule through the middle of the first line is beside the words
+        // ("4. Handoff rule ——"), not under them: pushing the card's content
+        // down for it shoved four bodies past the slot (gtm-03). Lower in the
+        // line, or under it, the text has run onto its divider.
+        const n = measured.get(t.id)?.lines;
+        if (n >= 1 && ly > r.y + r.h / n / 4 && ly < r.y + (r.h / n) * 0.75) continue;
+        if (r.y < ly - 1 && r.y + r.h > ly + 1 && (!best || need > best.need)) best = { need, y: ly };
+      }
+    }
+    return best;
+  };
+  // 0a. seat — a text the reader seated in the middle or at the bottom of its
+  // carrier sits there by its MEASURED height (seat.mjs): the painting's
+  // height was a plan, the ramp's type is taller or shorter. A text its
+  // carrier cannot hold within the insets is the levers' below (they grow the
+  // card and re-seat its content), not a seat's.
+  // Every member of a block follows: an icon's centre stays on its text's
+  // line, the lines under a grown text keep their gaps.
+  const atRect = (o) => (isText(o) ? { x: o.x, w: o.w, ...at(o) } : o);
+  // Only a child whose structure the normaliser recorded (seatBand, seatInset)
+  // is re-seated: an inset read off the current position would drift by the
+  // measured height on every pass.
+  for (const t of s.elements.filter((t) => t.parent && ["middle", "bottom", "span"].includes(seatOf(t)?.y) && !isStale(t) && t.seatBand && t.seatInset && (isText(t) || t.seatBand.y?.block?.length))) {
+    const p = byId.get(t.parent);
+    if (!p || !filled(p) || !(p.h > 0) || t.w <= 0 || t.h <= 0) continue;
+    const r = atRect(t);
+    // Its frame: the row between its dividers or neighbours, measured now.
+    const f = seatFrame(s, t, p, atRect);
+    if (r.h > f.h - 1 || (f.h === p.h && isText(t) && r.h + 2 * INSET > p.h + 0.5)) continue;
+    const top = seatRect(t, f, { w: t.w, h: r.h }, { spec: s, at: atRect })?.y;
+    const dy = top == null ? 0 : Math.round((top - r.y) * 2) / 2;
+    if (!dy) continue;
+    for (const o of subtree(t)) move(o, dy);
+    changes.push(`${t.id}: ${dy > 0 ? "+" : ""}${dy}px to sit ${seatOf(t).y === "bottom" ? "at the bottom of" : "in the middle of"} ${f.h === p.h ? p.id : `its row in ${p.id}`}`);
+  }
+  // 0b. stack — a declared stack is laid out again on its rows' MEASURED
+  // heights (stack.mjs): even gaps stay even, a divider rides with its row.
+  // A stack holding a text the ink fit just re-wrapped waits for the render.
+  if (s.stacks?.length) {
+    const live = { ...s, stacks: s.stacks.filter((g) => !g.rows.flat().some((id) => stale.has(id))) };
+    changes.push(...applyStacks(live, { at: atRect, move: (o, dy) => move(o, dy) }));
+  }
+  // 0c. block dividers — a rule between two paragraphs of one block sits at
+  // that boundary on the measured paragraphs (block-dividers.mjs).
+  changes.push(...placeBlockDividers(s, measured, { moveLine }));
+  // 0. round — a disc keeps its shape, so a text past its edge fits by the
+  // disc's own room: the content (icon and words together) centred in it,
+  // else the text as wide as the disc's chord at the rows it would take there.
+  // A disc of a declared set, or one with undeclared lookalikes, never changes
+  // alone: every member takes the same lift (the one its fullest member needs,
+  // their tops kept alike) and its corresponding texts the same chord width,
+  // or none does (x47-03: three lookalike step discs, each left spilling).
+  const round = new Set();
+  for (const d of s.elements.filter((d) => isRound(d) && pastOf(d) > ESCAPE_PX)) {
+    if (round.has(d)) continue;
+    const u = unitOf(d);
+    const group = u.members.length > 1 ? u.members : [d, ...s.elements.filter((o) => looksLike(o, d))];
+    for (const g of group) round.add(g);
+    if (group.some((g) => !isRound(g) || isStale(g))) continue;
+    const content = group.map((g) => {
+      const items = kids(g).map((k) => ({ k, top: isText(k) ? at(k).y : k.y, bottom: (isText(k) ? at(k).y : k.y) + heightOf(k) }));
+      const top = Math.min(...items.map((it) => it.top));
+      const bottom = Math.max(...items.map((it) => it.bottom));
+      return { g, items, top, bottom, dy: g.y + g.h / 2 - (top + bottom) / 2 };
+    });
+    const dy = Math.round(Math.min(...content.map((c) => c.dy)) * 10) / 10;
+    if (dy < 0 && content.every((c) => c.top + dy >= c.g.y + INSET - 0.5 && c.bottom + dy <= c.g.y + c.g.h - INSET + 0.5)) {
+      for (const c of content) {
+        for (const it of c.items) for (const o of subtree(it.k)) move(o, dy);
+        changes.push(`${c.g.id}: content ${dy}px to sit inside it${group.length > 1 ? " (its set alike)" : ""}`);
+      }
+      continue;
+    }
+    const lists = group.map(textsOf);
+    if (lists.some((l) => l.length !== lists[0].length)) continue;
+    for (const k of lists[0].keys()) {
+      const col = lists.map((l) => l[k]);
+      if (col.every((t) => measured.get(t.id)?.lines <= 1)) continue;
+      const w = Math.min(...col.map((t, i) => Math.floor(group[i].w * Math.sqrt(Math.max(0, 1 - (at(t).h / group[i].h) ** 2)) - 2 * INSET)));
+      // Never narrower than a member already is, and only for a real gain.
+      if (col.some((t) => t.w > w) || col.every((t) => w - t.w < MIN_GAIN)) continue;
+      col.forEach((t, i) => {
+        const g = group[i];
+        if (t.w === w) return;
+        changes.push(`${t.id}: width ${Math.round(t.w)}→${w}px to fit ${g.id}`);
+        t.x = Math.round((g.x + g.w / 2 - w / 2) * 10) / 10;
+        t.w = w;
+        round.add(t);
+      });
+    }
+  }
+
+  const units = [];
+  const spills = new Set();
+  for (const c of s.elements.filter((c) => isCard(c) && !isStale(c))) {
+    const spill = pastOf(c) > ESCAPE_PX || crossingOf(c);
+    if (!spill && !textsOf(c).some((t) => stackUnder(env, t))) continue;
+    const u = unitOf(c);
+    if (spill) spills.add(u);
+    if (!units.includes(u)) units.push(u);
+  }
+  const alone = (u) => u.members.length === 1 && lookalike(u.members[0]);
+  // Free width beside a text at the rows it takes now, within [left, right]:
+  // other elements, and the lines crossing those rows (a card's rules either
+  // side of an "OR", a loop around the card).
+  const roomBeside = (e, left, right) => {
+    const r0 = at(e);
+    const others = [
+      ...s.elements.filter((o) => !inTree(o, e) && !inTree(e, o) && o.w > 0 && o.h > 0)
+        .map((o) => ({ x: o.x, w: o.w, y: isText(o) ? at(o).y : o.y, h: heightOf(o) })),
+      ...lineSpans(s, r0.y, r0.y + r0.h, new Set(s.elements.filter((o) => inTree(o, e) || inTree(e, o)).map((o) => o.id)))
+        .map((l) => ({ ...l, y: r0.y, h: r0.h })),
+    ];
+    for (const o of others) {
+      if (!span(o.y, o.y + o.h, r0.y, r0.y + r0.h)) continue;
+      if (o.x >= e.x + e.w - 1) right = Math.min(right, o.x - GAP);
+      else if (o.x + o.w <= e.x + 1) left = Math.max(left, o.x + o.w + GAP);
+    }
+    return e.align === "center"
+      ? 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;
+  };
+  const widenTo = (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)}→${w}px ${why}`);
+    e.w = w;
+  };
+
+  // 1. widen — one width per corresponding text across the set.
+  const widenUnit = (u) => {
+    const mark = changes.length;
+    const lists = u.members.map(textsOf);
+    // Corresponding texts across the set share one width; unmatched ones fit alone.
+    const sets = lists.every((l) => l.length === lists[0].length)
+      ? lists[0].map((_, k) => lists.map((l, i) => [u.members[i], l[k]]))
+      : lists.flatMap((l, i) => l.map((t) => [[u.members[i], t]]));
+    for (const set of sets) {
+      // Only a text that wraps gets shorter by widening (a one-line label does not).
+      if (!set.some(([, t]) => !(measured.get(t.id)?.lines <= 1))) continue;
+      const w = Math.floor(Math.min(...set.map(([c, t]) => roomBeside(t, c.x + INSET, c.x + c.w - INSET))));
+      for (const [card, e] of set) if (w - e.w >= MIN_GAIN) widenTo(e, w, `to fit ${card.id}`);
+    }
+    return changes.length > mark;
+  };
+
+  // 1b. rows — a divider a text runs through moves down, with everything under
+  // it, by the same px on every member (the set keeps one inner layout). The
+  // move is rigid, so the new height it may need is placed in the same pass;
+  // where the card cannot take that height the divider stays (pushing the
+  // content out of the card trades one defect for a worse one, pm-03).
+  const dividerUnit = (u) => {
+    if (alone(u)) return false;
+    const hits = u.members.map(crossingOf);
+    const lead = hits.findIndex(Boolean);
+    if (lead < 0) return false;
+    const d = Math.max(...hits.filter(Boolean).map((h) => h.need));
+    const rel = hits[lead].y - u.members[lead].y;
+    const plans = u.members.map((card) => {
+      const line = linesWithin(s, card).find((c) => linePoints(c).every((p) => Math.abs(p.y - card.y - rel) <= 2));
+      if (!line) return null;
+      const y = card.y + rel;
+      return {
+        card,
+        items: kids(card).filter((k) => (isText(k) ? at(k).y : k.y) >= y - 1).flatMap(subtree),
+        lines: linesWithin(s, card).filter((c) => Math.min(...linePoints(c).map((p) => p.y)) >= y - 1),
+      };
+    });
+    if (plans.some((p) => !p)) return false;
+    // Nothing it carries crosses a line or lands on what stays (a full-width
+    // line, a text over the card).
+    const items = plans.flatMap((p) => p.items);
+    if (!clearOf(items, plans.flatMap((p) => p.lines), d) || landsOn(items, d)) return false;
+    const push = (dy) => {
+      for (const p of plans) {
+        for (const o of p.items) move(o, dy);
+        for (const c of p.lines) moveLine(c, 0, dy);
+      }
+    };
+    push(d);
+    const mark = changes.length;
+    if (u.members.some((c) => pastOf(c) > ESCAPE_PX) && !heightUnit(u)) {
+      push(-d);
+      return false;
+    }
+    changes.splice(mark, 0, ...plans.map(({ card }) => `${card.id}: content from its divider down +${d}px`));
+    return true;
+  };
+
+  // 2. the disc beside the text one step smaller on EVERY member; each text
+  // takes the width its disc gave up.
+  const discBeside = (card) => {
+    const b = block(card);
+    if (!b) return null;
+    const left = Math.min(...b.texts.map((t) => t.x));
+    const right = Math.max(...b.texts.map((t) => t.x + t.w));
+    // One disc beside the words: a list of rows with a disc each (cloud-08's
+    // four decisions) would lose its symmetry to one smaller disc.
+    const beside = kids(card).filter((d) => fixedAspect(d) && filled(d)
+      && Math.min(d.y + d.h, b.bottom) - Math.max(d.y, b.top) >= d.h / 2
+      && (d.x + d.w <= left + 1 || d.x >= right - 1));
+    return beside.length === 1 && !beside[0].fitScale ? beside[0] : null;
+  };
+  const discUnit = (u) => {
+    if (alone(u)) return false;
+    const discs = u.members.map(discBeside);
+    if (discs.some((d) => !d)) return false;
+    u.members.forEach((card, i) => {
+      const d = discs[i];
+      const onLeft = d.x + d.w <= Math.min(...textsOf(card).map((t) => t.x)) + 1;
+      const cx = d.x + d.w / 2;
+      const cy = d.y + d.h / 2;
+      const w = Math.round(d.w * DISC_SCALE);
+      const h = Math.round(d.h * DISC_SCALE);
+      const freed = d.w - w;
+      const ncx = onLeft ? d.x + w / 2 : d.x + d.w - w / 2;
+      for (const o of subtree(d).slice(1)) {
+        const ow = o.w * DISC_SCALE;
+        const oh = o.h * DISC_SCALE;
+        translateElement(o, ncx + (o.x + o.w / 2 - cx) * DISC_SCALE - ow / 2 - o.x, cy + (o.y + o.h / 2 - cy) * DISC_SCALE - oh / 2 - o.y);
+        o.w = Math.round(ow);
+        o.h = Math.round(oh);
+      }
+      const was = d.w;
+      d.x = Math.round(ncx - w / 2);
+      d.y = Math.round(cy - h / 2);
+      d.w = w;
+      d.h = h;
+      d.fitScale = DISC_SCALE;
+      for (const t of textsOf(card)) {
+        if (onLeft) t.x -= freed;
+        t.w += freed;
+      }
+      changes.push(`${d.id}: ${was}→${w}px, ${textsOf(card).map((t) => t.id).join(", ")} +${freed}px wide`);
+    });
+    return true;
+  };
+
+  // 3. one height, placed by the set's arrangement, all or nothing (card-height.mjs).
+  const { heightUnit, crossesLine } = cardHeight({ s, byId, slot, changes, at, ink: (t) => inkOf(env, t), heightOf, isText, filled, kids, subtree, inTree, move, block, pastOf, alone });
+  // 1a. stack — a text grown into what is stacked beneath it (text-stack.mjs):
+  // a marker lifts clear of its label where it has the room; else the stack
+  // moves down, every member of a set by the same px, into its free room, or
+  // with the one new height (3) its card can take; else the text — or the
+  // first text of its stack — widens where that saves one of its lines.
+  const shiftStacks = (hits, d) => {
+    for (const h of hits) {
+      for (const o of h.members) move(o, d);
+      for (const c of h.lines) moveLine(c, 0, d);
+    }
+  };
+  // Where a moving element is drawn: a text's glyphs (a line through its
+  // box's empty margin crosses nothing), anything else its rect.
+  const drawn = (o, dy = 0) => {
+    if (!isText(o)) return { x: o.x, y: o.y + dy, w: o.w, h: o.h };
+    const [x0, x1] = columnOf(env, o);
+    const g = inkOf(env, o);
+    return { x: x0, y: g.top + dy, w: x1 - x0, h: g.bottom - g.top };
+  };
+  // Moved by dy, no element crosses a line it did not cross before — member
+  // by member: a line between two rows of a stack lies inside its outline.
+  const clearOf = (members, lines, dy) => members.every((o) => !(o.w > 0 && o.h > 0) || !crossesLine(drawn(o, dy), [drawn(o)], members, lines));
+  // …nor lands on an element that stays and that it did not touch (its own card never counts).
+  const landsOn = (members, dy) => members.some((o) => o.w > 0 && o.h > 0 && s.elements.some((f) => !members.includes(f) && !inTree(o, f)
+    && f.w > 0 && f.h > 0 && !hit(drawn(f), drawn(o)) && hit(drawn(f), drawn(o, dy))));
+  const pushLever = (col, hits, grow) => {
+    // The image's gap where the room holds it, else just clear of each other.
+    const need = Math.max(...hits.map((h) => h.need));
+    const least = Math.max(...hits.map((h) => h.least));
+    const up = col.every(isMarker) ? Math.min(...col.map((t) => markerRoom(env, t).up)) : -1;
+    const lift = up >= need ? need : least;
+    if (up >= least && col.every((t) => clearOf(subtree(t), [], -lift))) {
+      for (const [i, t] of col.entries()) {
+        for (const o of subtree(t)) move(o, -lift);
+        changes.push(`${t.id}: lifted ${lift}px clear of ${hits[i].first.id}`);
+      }
+      return true;
+    }
+    const d = hits.every((h) => h.room >= need) || least > Math.min(...hits.map((h) => h.room)) ? need : least;
+    const clear = (h) => clearOf(h.members, h.lines, d);
+    const notes = hits.map((h) => `${h.first.id}${h.members.length > 1 ? ` and ${h.members.length - 1} under it` : ""}: +${d}px down, clear of ${h.t.id}`);
+    if (!hits.every(clear)) return false;
+    if (hits.every((h) => h.room >= d)) {
+      shiftStacks(hits, d);
+      changes.push(...notes);
+      return true;
+    }
+    // Only the card's own bottom is worth a new height: growing it never
+    // clears what lies under the stack inside it. The height lever judges
+    // what the content lands on from where it was before this push.
+    if (!grow || hits.some((h) => h.blocker)) return false;
+    shiftStacks(hits, d);
+    const mark = changes.length;
+    if (grow(new Map(hits.flatMap((h) => h.members.map((o) => [o, d]))))) {
+      changes.splice(mark, 0, ...notes);
+      return true;
+    }
+    shiftStacks(hits, -d);
+    return false;
+  };
+  // Only a width that saves a line is worth it: its lines, run full, one fewer.
+  const widenLever = (col, bounds, why) => {
+    const lines = col.map((t) => measured.get(t.id)?.lines ?? 0);
+    if (col.some((t, i) => !(lines[i] > hardLineCount(t)))) return false;
+    const w = Math.floor(Math.min(...col.map((t) => roomBeside(t, ...bounds(t)))));
+    if (!col.every((t, i) => w - t.w >= MIN_GAIN && w >= (t.w * lines[i]) / (lines[i] - 1))) return false;
+    for (const t of col) widenTo(t, w, why);
+    return true;
+  };
+  const inner = (card) => () => [card.x + INSET, card.x + card.w - INSET];
+  // Pushes are rigid, so every stack of a card moves in the same pass, top
+  // down; a widen changes a text's lines and waits for the next render.
+  const stackUnit = (u) => {
+    const lists = u.members.map(textsOf);
+    if (lists.some((l) => l.length !== lists[0].length)) return false;
+    let acted = false;
+    for (const k of lists[0].keys()) {
+      const col = lists.map((l) => l[k]);
+      const found = col.map((t) => stackUnder(env, t));
+      if (!found.some(Boolean)) continue;
+      // A set moves alike: the members t does not reach move by the same px.
+      const hits = col.map((t, i) => found[i] ?? stackUnder(env, t, { force: true }));
+      if (hits.some((h) => !h || h.members.some(isStale))) continue;
+      if (pushLever(col, hits, alone(u) ? null : (pushed) => heightUnit(u, pushed))) {
+        acted = true;
+        continue;
+      }
+      const firsts = hits.map((h) => h.first);
+      if (widenLever(col, (t) => inner(byId.get(t.parent))(), `to clear ${firsts[0].id}`)) return true;
+      if (firsts.every(isText) && widenLever(firsts, (t) => inner(byId.get(t.parent))(), `to make room under ${col[0].id}`)) return true;
+    }
+    return acted;
+  };
+
+  const touched = new Set();
+  for (const u of units) {
+    const levers = spills.has(u) ? [widenUnit, dividerUnit, stackUnit, discUnit, heightUnit] : [stackUnit];
+    if (levers.some((lever) => lever(u))) for (const c of u.members) touched.add(c);
+  }
+
+  // S. slot — a text that ends past the slot's bottom, or past a card no lever
+  // above could fit, lifts into the free room above it: with the texts stacked
+  // on it (a title over its body) and the texts beside it on the same top (a
+  // row of labels stays one row), never onto a neighbour or across a line. A
+  // text on no card first widens into the room beside it where that saves a
+  // line (the slot's edges, its neighbours, a panel it lies on).
+  const cardOf = (t) => {
+    for (let p = t.parent ? byId.get(t.parent) : null, g = 0; p && g < 32; p = p.parent ? byId.get(p.parent) : null, g++) if (filled(p)) return p;
+    return null;
+  };
+  const bottomOf = (t) => at(t).y + at(t).h;
+  const pastBy = (t) => Math.max(bottomOf(t) - slot.h, cardOf(t) ? bottomOf(t) - cardOf(t).y - cardOf(t).h : -Infinity);
+  const flagged = (t) => bottomOf(t) - slot.h > SLOT_PX || (cardOf(t) && bottomOf(t) - cardOf(t).y - cardOf(t).h > ESCAPE_PX);
+  const stackOf = (t) => {
+    const stack = [t];
+    for (let top = t; top;) {
+      top = s.elements.filter((o) => isText(o) && !stack.includes(o) && o.parent === t.parent && span(o.x, o.x + o.w, top.x, top.x + top.w)
+        && at(o).y < at(top).y && at(top).y - (at(o).y + at(o).h) <= STACK_GAP).sort((a, b) => at(b).y - at(a).y)[0];
+      if (top) stack.push(top);
+    }
+    const x0 = Math.min(...stack.map((o) => o.x));
+    const x1 = Math.max(...stack.map((o) => o.x + o.w));
+    const top = Math.min(...stack.map((o) => at(o).y));
+    const card = cardOf(t);
+    let ceil = card ? card.y + INSET : 0;
+    for (const o of s.elements) {
+      if (stack.some((k) => inTree(o, k) || inTree(k, o)) || !(o.w > 0 && o.h > 0) || !span(o.x, o.x + o.w, x0, x1)) continue;
+      const oy = isText(o) ? at(o).y : o.y;
+      if (oy + heightOf(o) <= top + 1) ceil = Math.max(ceil, oy + heightOf(o) + GAP);
+    }
+    return { stack, room: Math.floor(top - ceil) };
+  };
+  // The width a text on no card may take: the slot, or the panel it lies on.
+  const panelBounds = (t) => {
+    const r = at(t);
+    let left = 0;
+    let right = slot.w;
+    for (const p of s.elements) {
+      if (!filled(p) || inTree(t, p) || !hit(p, { x: t.x, y: r.y, w: t.w, h: r.h }) || p.x > t.x || p.x + p.w < t.x + t.w) continue;
+      left = Math.max(left, p.x + INSET);
+      right = Math.min(right, p.x + p.w - INSET);
+    }
+    return [left, right];
+  };
+  // 1a on no card: the same for texts on the slide itself (a step's number
+  // over its label, a title over its body), top-down; a push is rigid, so a
+  // text it moved is measured where it now is, a widened one waits.
+  const widened = new Set();
+  for (const t of s.elements.filter((t) => isText(t) && !cardOf(t) && !isStale(t)).sort((a, b) => at(a).y - at(b).y)) {
+    if (widened.has(t)) continue;
+    const h = stackUnder(env, t);
+    if (!h || h.members.some((o) => isStale(o) || widened.has(o)) || pushLever([t], [h], null)) continue;
+    if (widenLever([t], panelBounds, `to clear ${h.first.id}`)) widened.add(t);
+    else if (isText(h.first) && widenLever([h.first], panelBounds, `to make room under ${t.id}`)) widened.add(h.first);
+  }
+
+  const done = new Set();
+  for (const t of s.elements.filter((t) => isText(t) && flagged(t) && !isStale(t) && !widened.has(t))) {
+    // A disc is the round lever's (0): lifted in it, a line leaves its outline.
+    // A card of a declared set, or one with undeclared lookalikes, changes
+    // with the others or not at all: a lift in one member alone breaks its
+    // inner layout (alone() guards the card levers the same way).
+    const card = cardOf(t);
+    if (done.has(t) || touched.has(card) || fixedAspect(card ?? {}) || (card && isStale(card))
+      || (card && (unitOf(card).members.length > 1 || (isCard(card) && lookalike(card))))) continue;
+    const lines = measured.get(t.id)?.lines;
+    if (!cardOf(t) && lines > hardLineCount(t)) {
+      // Only a width that saves a line is worth it: its lines, run full, one fewer.
+      const w = Math.floor(roomBeside(t, ...panelBounds(t)));
+      if (w - t.w >= MIN_GAIN && w >= (t.w * lines) / (lines - 1)) {
+        widenTo(t, w, "to end inside the slot");
+        done.add(t);
+        continue;
+      }
+    }
+    const row = s.elements.filter((o) => isText(o) && !done.has(o) && o.parent === t.parent && Math.abs(at(o).y - at(t).y) <= 1);
+    for (const o of row) done.add(o);
+    const stacks = row.map(stackOf);
+    // As far as the whole row can go, and only when that brings at least one
+    // of its texts inside: a lift that fixes nothing is only a move.
+    const d = Math.min(Math.ceil(Math.max(...row.map(pastBy))), ...stacks.map((k) => k.room));
+    if (!(d >= 1) || !row.some((o) => flagged(o) && pastBy(o) <= d)) continue;
+    const lifted = [...new Set(stacks.flatMap((k) => k.stack))];
+    if (lifted.some((o) => crossesLine({ x: o.x, y: at(o).y - d, w: o.w, h: at(o).h }, [{ x: o.x, y: at(o).y, w: o.w, h: at(o).h }], []))) continue;
+    for (const o of lifted) for (const k of subtree(o)) move(k, -d);
+    changes.push(`${lifted.map((o) => o.id).join(", ")}: lifted ${d}px to end inside ${cardOf(t)?.id ?? "the slot"}`);
+  }
+  return { spec: s, changes };
+}