wand-decks-kit 0.8.0

package/lib/layouts_dense.js

@@ -0,0 +1,361 @@
+/**
+ * lib/layouts_dense.js — layouts for dense enterprise decks.
+ *
+ * The base kit was measured off Infinite Labor, a narrative investor deck.
+ * Dense client decks carry 30-50 shapes a slide: roadmaps, layered
+ * architecture, categorised matrices, proof-point walls. These are those.
+ *
+ * Loaded and re-exported by wand_kit.js — call them as W.phaseCards(...) etc.
+ */
+
+module.exports = function attach(W) {
+  const { T, F, COLS, ASSETS, radius, theme, autoSize, contentTop,
+          background, chrome, footer, title, subtitle, kicker,
+          card, iconTile, pill } = W;
+
+  /**
+   * L14 phaseCards — a 4-step roadmap. Each card carries a step number, a
+   * period, a title and a bullet list. Card 1 is the emphasis card.
+   * phases: [{ period, title, bullets: [] }]
+   */
+  function phaseCards(pres, { tag, titleText, subtitleText, phases, dark = true, deck, n, total }) {
+    const s = pres.addSlide();
+    background(s, dark);
+    chrome(s, { tag, dark });
+    title(s, titleText, { dark, y: 0.62, h: 0.5 });
+    if (subtitleText) subtitle(s, subtitleText, { dark, y: 1.14, h: 0.40 });
+    const th = theme(dark);
+    const xs = [0.41, 2.71, 5.01, 7.31], w = 2.20;
+    const top = contentTop(titleText, subtitleText, { titleY: 0.62, gap: 0.30 });
+    phases.slice(0, 4).forEach((ph, i) => {
+      const x = xs[i], y = top, h = 4.96 - top;
+      card(s, { x, y, w, h, dark, variant: i === 0 ? "emph" : "glass" });
+      const ink = i === 0 ? T.white : th.ink;
+      s.addText(String(i + 1), {
+        x: x + 0.20, y: y + 0.16, w: 0.60, h: 0.36, margin: 0, isTextBox: true,
+        fontFace: F.semi, fontSize: 20, color: i === 0 ? T.accentSoft : T.accent, valign: "middle",
+      });
+      s.addText(ph.period, {
+        x: x + 0.20, y: y + 0.56, w: w - 0.40, h: 0.22, margin: 0, isTextBox: true,
+        fontFace: F.med, fontSize: 9, color: i === 0 ? T.accentPale : T.accentDeep, valign: "middle",
+      });
+      s.addText(ph.title, {
+        x: x + 0.20, y: y + 0.80, w: w - 0.40, h: 0.30, margin: 0, isTextBox: true,
+        fontFace: F.semi,
+        fontSize: autoSize(ph.title, w - 0.40, 0.30, { family: F.semi, fontSize: 11, min: 9 }),
+        color: ink, valign: "middle",
+      });
+      s.addText(
+        ph.bullets.slice(0, 5).map((b, j, arr) => ({
+          text: b, options: { bullet: { code: "2022" }, breakLine: j !== arr.length - 1 },
+        })),
+        { x: x + 0.22, y: y + 1.18, w: w - 0.42, h: h - 1.32, margin: 0, isTextBox: true,
+          fontFace: F.reg, fontSize: 8, color: i === 0 ? T.bodyDarkAlt : th.body,
+          valign: "top", paraSpaceAfter: 3, lineSpacingMultiple: 1.15 }
+      );
+    });
+    if (deck) footer(s, { deck, n, total, dark });
+    return s;
+  }
+
+  /**
+   * numberedCards — 2-4 cards each led by a big ordinal. For "three strategic
+   * priorities" style slides where the number is the organising device.
+   * items: [{ eyebrow, number, title, badge, body }]
+   */
+  function numberedCards(pres, { tag, titleText, subtitleText, items, dark = true, deck, n, total }) {
+    const s = pres.addSlide();
+    background(s, dark);
+    chrome(s, { tag, dark });
+    title(s, titleText, { dark, y: 0.62, h: 0.5 });
+    if (subtitleText) subtitle(s, subtitleText, { dark, y: 1.14, h: 0.46 });
+    const th = theme(dark);
+    const three = items.length >= 3;
+    const w = three ? 2.90 : 4.25;
+    const xs = three ? COLS["3wide"].x : COLS[2].x;
+    const top = contentTop(titleText, subtitleText, { titleY: 0.62, gap: 0.32 });
+    items.slice(0, 3).forEach((it, i) => {
+      const x = xs[i], y = top, h = 4.96 - top;
+      card(s, { x, y, w, h, dark, variant: it.emph ? "emph" : "glass" });
+      if (it.eyebrow) s.addText(it.eyebrow.toUpperCase(), {
+        x: x + 0.24, y: y + 0.22, w: w - 0.48, h: 0.18, margin: 0, isTextBox: true,
+        fontFace: F.med, fontSize: 7.5, color: th.eyebrow, valign: "middle",
+      });
+      s.addText(String(it.number), {
+        x: x + 0.24, y: y + 0.42, w: w - 0.48, h: 0.52, margin: 0, isTextBox: true,
+        fontFace: F.xbold,
+        fontSize: autoSize(String(it.number), w - 0.48, 0.52, { family: F.xbold, fontSize: 30, min: 14 }),
+        color: T.accent, valign: "middle",
+      });
+      s.addText(it.title, {
+        x: x + 0.24, y: y + 1.02, w: w - 0.48, h: 0.52, margin: 0, isTextBox: true,
+        fontFace: F.semi,
+        fontSize: autoSize(it.title, w - 0.48, 0.52, { family: F.semi, fontSize: 14, min: 11, lineSpacingMultiple: 1.15 }),
+        color: th.ink, valign: "top", lineSpacingMultiple: 1.15,
+      });
+      if (it.badge) s.addText(it.badge, {
+        x: x + 0.24, y: y + 1.58, w: w - 0.48, h: 0.20, margin: 0, isTextBox: true,
+        fontFace: F.med, fontSize: 8.5, italic: true, color: T.accentDeep, valign: "middle",
+      });
+      s.addText(it.body, {
+        x: x + 0.24, y: y + 1.86, w: w - 0.48, h: h - 2.00, margin: 0, isTextBox: true,
+        fontFace: F.reg, fontSize: 8.5, color: th.body, valign: "top", lineSpacingMultiple: 1.25,
+      });
+    });
+    if (deck) footer(s, { deck, n, total, dark });
+    return s;
+  }
+
+  /**
+   * archStack — a layered architecture diagram: a top actor band, a governed
+   * middle layer holding N modules, a row of source cards, and an outcome band.
+   * This is the shape every "we sit between your people and your vendors" slide
+   * wants, and nothing in the catalog covers it.
+   *
+   * top:     { label, body }
+   * middle:  { label, modules: [{ title, body }] }
+   * sources: { eyebrow, cards: [{ title, body, ours }] }
+   * outcome: string
+   */
+  function archStack(pres, { tag, titleText, subtitleText, top, middle, note, sources, outcome, dark = true, deck, n, total }) {
+    const s = pres.addSlide();
+    background(s, dark);
+    chrome(s, { tag, dark });
+    title(s, titleText, { dark, y: 0.58, h: 0.44 });
+    if (subtitleText) subtitle(s, subtitleText, { dark, y: 1.04, h: 0.28 });
+    const th = theme(dark);
+    const L = 0.37, WIDTH = 9.25;
+
+    // The stack is laid out from the measured content top down to the y5.05
+    // hard limit, so a two-line title can never push the outcome band into the
+    // footer. Heights are proportional; only the start moves.
+    const topY = contentTop(titleText, subtitleText, { titleY: 0.58, gap: 0.20 });
+    const BOTTOM = 5.02;
+    const outcomeH = outcome ? 0.40 : 0;
+    const modules = (middle.modules || []).slice(0, 6);
+    const hasMods = modules.length > 0;
+    const pool = BOTTOM - topY - outcomeH - 0.42;      // 3 inter-block gaps
+    const bandH = Math.max(0.42, pool * 0.16);
+    // With no modules the middle band is just a connector — don't let it balloon.
+    let midH = hasMods ? Math.max(1.05, pool * 0.42) : 0.56;
+    // One long module body used to drag the whole row down to 5.5pt, which is
+    // unreadable rather than merely tight. Grow the band toward what the longest
+    // body actually needs, borrowing the height from the source row below.
+    if (hasMods) {
+      const mwT = (WIDTH - 0.48 - 0.16 * (modules.length - 1)) / modules.length;
+      const worst = modules.reduce((a, m) => ((m.body || "").length > (a.body || "").length ? m : a), modules[0]);
+      const cap = pool * 0.56;
+      while (midH < cap &&
+             autoSize(worst.body || "", mwT - 0.20, midH - 0.88,
+                      { family: F.reg, fontSize: 7.5, min: 5.5, lineSpacingMultiple: 1.15 }) < 7) {
+        midH += 0.05;
+      }
+    }
+    const srcH = Math.max(0.92, pool * (hasMods ? 0.42 : 0.62));
+    const my = topY + bandH + 0.14;
+    const sy = my + midH + 0.36;
+    // Clamp: the outcome band must land inside the content limit, so the source
+    // row gives up whatever height is needed rather than pushing past it.
+    const oy = Math.min(sy + srcH + 0.14, BOTTOM - outcomeH);
+    const srcHc = outcome ? oy - 0.14 - sy : srcH;
+
+    // actor band
+    s.addShape("roundRect", {
+      x: L, y: topY, w: WIDTH, h: bandH, rectRadius: radius(WIDTH, bandH),
+      fill: { color: dark ? T.cardMuted : T.surface },
+      line: { color: dark ? T.cardMutedStroke : T.divider, width: 1 },
+    });
+    s.addText(top.label.toUpperCase(), {
+      x: L + 0.24, y: topY, w: 2.6, h: bandH, margin: 0, isTextBox: true,
+      fontFace: F.semi, fontSize: 9, color: T.accent, valign: "middle",
+    });
+    s.addText(top.body, {
+      x: L + 2.90, y: topY, w: WIDTH - 3.20, h: bandH, margin: 0, isTextBox: true,
+      fontFace: F.reg, fontSize: 8.5, color: th.body, valign: "middle",
+    });
+
+    // governed middle layer
+    const mh = midH;
+    s.addShape("roundRect", {
+      x: L, y: my, w: WIDTH, h: mh, rectRadius: radius(WIDTH, mh),
+      fill: { color: dark ? T.cardEmphFlat : T.cardLight },
+      line: { color: T.accent, width: 1.25 },
+    });
+    const mods = modules;
+    const mw = mods.length ? (WIDTH - 0.48 - 0.16 * (mods.length - 1)) / mods.length : 0;
+    s.addText(middle.label, {
+      x: L + 0.24, y: my + (mods.length ? 0.12 : 0), w: WIDTH - 0.48,
+      h: mods.length ? 0.24 : midH, margin: 0, isTextBox: true,
+      fontFace: F.semi, fontSize: mods.length ? 9 : 11,
+      color: dark ? T.white : T.accentDeep,
+      align: mods.length ? "left" : "center", valign: "middle",
+    });
+    mods.forEach((m, i) => {
+      const mx = L + 0.24 + i * (mw + 0.16);
+      const modH = mh - 0.52;
+      s.addShape("roundRect", {
+        x: mx, y: my + 0.44, w: mw, h: modH, rectRadius: radius(mw, modH),
+        fill: { color: dark ? "2A2160" : T.surface },
+        line: { color: dark ? T.cardMutedStroke : T.divider, width: 0.75 },
+      });
+      s.addText(m.title, {
+        x: mx + 0.12, y: my + 0.54, w: mw - 0.24, h: 0.24, margin: 0, isTextBox: true,
+        fontFace: F.semi,
+        fontSize: autoSize(m.title, mw - 0.24, 0.24, { family: F.semi, fontSize: 9.5, min: 7.5 }),
+        color: dark ? T.white : T.inkLight, align: "center", valign: "middle",
+      });
+      s.addText(m.body, {
+        x: mx + 0.10, y: my + 0.80, w: mw - 0.20, h: mh - 0.88, margin: 0, isTextBox: true,
+        fontFace: F.reg,
+        fontSize: autoSize(m.body, mw - 0.20, mh - 0.88, { family: F.reg, fontSize: 7.5, min: 5.5, lineSpacingMultiple: 1.15 }),
+        color: th.body,
+        align: "center", valign: "top", lineSpacingMultiple: 1.15,
+      });
+    });
+
+    // source cards
+    const sh = srcHc;
+    if (note) s.addText(note, {
+      x: L, y: my + midH + 0.04, w: WIDTH, h: 0.28, margin: 0, isTextBox: true,
+      fontFace: F.reg,
+      fontSize: autoSize(note, WIDTH, 0.28, { family: F.reg, fontSize: 8, min: 6 }),
+      color: th.body, align: "center", valign: "middle",
+    });
+    const ebW = sources && sources.eyebrow && sources.eyebrow.length > 34 ? WIDTH : 2.0;
+    if (sources && sources.eyebrow) s.addText(sources.eyebrow.toUpperCase(), {
+      x: L, y: sy - 0.24, w: ebW, h: 0.18, margin: 0, isTextBox: true,
+      fontFace: F.med,
+      fontSize: autoSize(sources.eyebrow.toUpperCase(), ebW, 0.18, { family: F.med, fontSize: 7.5, min: 5.5 }),
+      color: th.eyebrow, valign: "middle",
+    });
+    const sc = ((sources && sources.cards) || []).slice(0, 4);
+    const sw = (WIDTH - 0.22 * (sc.length - 1)) / sc.length;
+    sc.forEach((c, i) => {
+      const cx = L + i * (sw + 0.22);
+      card(s, { x: cx, y: sy, w: sw, h: sh, dark, variant: c.ours === false ? "muted" : "glass" });
+      s.addText(c.title, {
+        x: cx + 0.18, y: sy + 0.14, w: sw - 0.36, h: 0.26, margin: 0, isTextBox: true,
+        fontFace: F.semi,
+        fontSize: autoSize(c.title, sw - 0.36, 0.26, { family: F.semi, fontSize: 10.5, min: 8.5 }),
+        color: th.ink, valign: "middle",
+      });
+      s.addText(c.body, {
+        x: cx + 0.18, y: sy + 0.44, w: sw - 0.36, h: 0.56, margin: 0, isTextBox: true,
+        fontFace: F.reg, fontSize: 8, color: th.body, valign: "top", lineSpacingMultiple: 1.2,
+      });
+    });
+
+    // outcome band
+    if (outcome) {
+      s.addShape("roundRect", {
+        x: L, y: oy, w: WIDTH, h: outcomeH, rectRadius: radius(WIDTH, outcomeH),
+        fill: { color: dark ? T.cardMuted : T.surface },
+        line: { color: dark ? T.cardMutedStroke : T.divider, width: 1 },
+      });
+      s.addText(outcome, {
+        x: L + 0.24, y: oy, w: WIDTH - 0.48, h: outcomeH, margin: 0, isTextBox: true,
+        fontFace: F.med, fontSize: 8.5, color: dark ? T.bodyDarkAlt : T.accentDeep, valign: "middle",
+      });
+    }
+    if (deck) footer(s, { deck, n, total, dark });
+    return s;
+  }
+
+  /**
+   * matrixGrid — categorised cells: N category columns, each holding M items.
+   * For capability maps and use-case inventories. Handles 3-4 columns x 3 rows.
+   * groups: [{ category, items: [{ title, body }] }]
+   */
+  function matrixGrid(pres, { tag, titleText, subtitleText, groups, kickerText, dark = false, deck, n, total }) {
+    const s = pres.addSlide();
+    background(s, dark);
+    chrome(s, { tag, dark });
+    title(s, titleText, { dark, y: 0.58, h: 0.44 });
+    if (subtitleText) subtitle(s, subtitleText, { dark, y: 1.04, h: 0.30 });
+    const th = theme(dark);
+    const g = groups.slice(0, 4);
+    const L = 0.37, WIDTH = 9.25, GAP = 0.20;
+    const cw = (WIDTH - GAP * (g.length - 1)) / g.length;
+    const rows = Math.max(...g.map((x) => x.items.length));
+    const top = contentTop(titleText, subtitleText, { titleY: 0.58, gap: 0.42 });
+    const avail = 4.94 - top;
+    const step = avail / rows, rh = Math.min(0.92, step - 0.10);
+    g.forEach((grp, i) => {
+      const x = L + i * (cw + GAP);
+      s.addText(grp.category.toUpperCase(), {
+        x, y: top - 0.30, w: cw, h: 0.22, margin: 0, isTextBox: true,
+        fontFace: F.semi, fontSize: 8.5, color: T.accent, valign: "middle",
+      });
+      grp.items.slice(0, rows).forEach((it, j) => {
+        const y = top + j * step;
+        card(s, { x, y, w: cw, h: rh, dark });
+        s.addText(it.title, {
+          x: x + 0.16, y: y + 0.12, w: cw - 0.32, h: 0.24, margin: 0, isTextBox: true,
+          fontFace: F.semi,
+          fontSize: autoSize(it.title, cw - 0.32, 0.24, { family: F.semi, fontSize: 10, min: 8 }),
+          color: th.ink, valign: "middle",
+        });
+        s.addText(it.body, {
+          x: x + 0.16, y: y + 0.38, w: cw - 0.32, h: rh - 0.48, margin: 0, isTextBox: true,
+          fontFace: F.reg, fontSize: 7.5, color: th.body, valign: "top", lineSpacingMultiple: 1.15,
+        });
+      });
+    });
+    if (kickerText) kicker(s, kickerText, { dark, y: 4.94 });
+    if (deck) footer(s, { deck, n, total, dark });
+    return s;
+  }
+
+  /**
+   * logoBands — stat cards over one or two labelled name rows. For proof-point
+   * slides: customers, investors, partners. Names are text, not logo images,
+   * because the source rarely ships usable transparent logos.
+   * stats: [{ value, caption }]   bands: [{ label, names, note }]
+   */
+  function logoBands(pres, { tag, titleText, subtitleText, stats, bands, dark = true, deck, n, total }) {
+    const s = pres.addSlide();
+    background(s, dark);
+    chrome(s, { tag, dark });
+    title(s, titleText, { dark, y: 0.62, h: 0.44 });
+    if (subtitleText) subtitle(s, subtitleText, { dark, y: 1.08, h: 0.30 });
+    const th = theme(dark);
+    const { w, x } = COLS["4stat"];
+    stats.slice(0, 4).forEach((it, i) => {
+      const cx = x[i], cy = 1.60;
+      card(s, { x: cx, y: cy, w, h: 1.34, dark });
+      s.addText(it.value, {
+        x: cx + 0.18, y: cy + 0.14, w: w - 0.36, h: 0.42, margin: 0, isTextBox: true,
+        fontFace: F.semi,
+        fontSize: autoSize(it.value, w - 0.36, 0.42, { family: F.semi, fontSize: 21, min: 14 }),
+        color: T.accent, valign: "middle",
+      });
+      s.addText(it.caption, {
+        x: cx + 0.18, y: cy + 0.62, w: w - 0.36, h: 0.58, margin: 0, isTextBox: true,
+        fontFace: F.reg, fontSize: 8.5, color: th.body, valign: "top", lineSpacingMultiple: 1.2,
+      });
+    });
+    bands.slice(0, 2).forEach((b, i) => {
+      const y = 3.20 + i * 0.96, h = b.note ? 0.84 : 0.62;
+      card(s, { x: 0.37, y, w: 9.25, h, dark, variant: i === 0 ? "glass" : "muted" });
+      s.addText(b.label.toUpperCase(), {
+        x: 0.61, y: y + 0.10, w: 3.0, h: 0.20, margin: 0, isTextBox: true,
+        fontFace: F.med, fontSize: 7.5, color: th.eyebrow, valign: "middle",
+      });
+      s.addText(b.names, {
+        x: 0.61, y: y + 0.28, w: 8.77, h: 0.26, margin: 0, isTextBox: true,
+        fontFace: F.semi,
+        fontSize: autoSize(b.names, 8.77, 0.26, { family: F.semi, fontSize: 11, min: 8 }),
+        color: th.ink, valign: "middle",
+      });
+      if (b.note) s.addText(b.note, {
+        x: 0.61, y: y + 0.54, w: 8.77, h: 0.24, margin: 0, isTextBox: true,
+        fontFace: F.reg, fontSize: 8, italic: true, color: th.body, valign: "middle",
+      });
+    });
+    if (deck) footer(s, { deck, n, total, dark });
+    return s;
+  }
+
+  Object.assign(W, { phaseCards, numberedCards, archStack, matrixGrid, logoBands });
+  return W;
+};

package/lib/measure.js

@@ -0,0 +1,109 @@
+/**
+ * lib/measure.js — real text metrics against the actual Geist faces.
+ *
+ * Why this exists: §9 says LibreOffice ignores embedded fonts and substitutes
+ * DejaVu, so QA renders over-report overflow and lose all weight information.
+ * That makes visual QA unreliable for exactly the thing it looks like it's
+ * checking. This module measures the real font, so overflow is a build-time
+ * error rather than a judgement call about a screenshot.
+ */
+
+const path = require("path");
+const FONTS = path.join(__dirname, "..", "fonts");
+
+/* family + style -> ttf stem, mirroring embed_fonts.py */
+const FACE = {
+  "Geist":            { r: "Geist-Regular",   b: "Geist-Bold",      i: "Geist-Italic",          bi: "Geist-BoldItalic" },
+  "Geist Medium":     { r: "Geist-Medium",    b: "Geist-SemiBold",  i: "Geist-MediumItalic",    bi: "Geist-SemiBoldItalic" },
+  "Geist SemiBold":   { r: "Geist-SemiBold",  b: "Geist-ExtraBold", i: "Geist-SemiBoldItalic",  bi: "Geist-ExtraBoldItalic" },
+  "Geist ExtraBold":  { r: "Geist-ExtraBold", b: "Geist-ExtraBold", i: "Geist-ExtraBoldItalic", bi: "Geist-ExtraBoldItalic" },
+  "Geist Light":      { r: "Geist-Light",     b: "Geist-Medium",    i: "Geist-LightItalic",     bi: "Geist-MediumItalic" },
+};
+
+let FONTKIT = null;
+const cache = new Map();
+function face(family = "Geist", { bold = false, italic = false } = {}) {
+  if (!FONTKIT) throw new Error("measure.js was loaded without fontkit — require it through the kit's lib/shared.js");
+  const set = FACE[family] || FACE["Geist"];
+  const stem = set[bold && italic ? "bi" : bold ? "b" : italic ? "i" : "r"];
+  if (!cache.has(stem)) cache.set(stem, FONTKIT.openSync(path.join(FONTS, stem + ".ttf")));
+  return cache.get(stem);
+}
+
+/** Width of a single line, in inches. */
+function widthIn(text, { family, fontSize, bold, italic } = {}) {
+  if (!text) return 0;
+  const f = face(family, { bold, italic });
+  const run = f.layout(String(text));
+  return (run.advanceWidth / f.unitsPerEm) * (fontSize / 72);
+}
+
+/**
+ * Greedy word wrap at a given box width. Returns the lines it would occupy.
+ * Honours explicit \n. Matches how PowerPoint breaks closely enough to catch
+ * the failures that matter (a line too many, a word that can't fit at all).
+ */
+function wrap(text, boxWidthIn, opts = {}) {
+  const out = [];
+  for (const para of String(text).split("\n")) {
+    const words = para.split(/\s+/).filter(Boolean);
+    if (!words.length) { out.push(""); continue; }
+    let line = words[0];
+    for (let i = 1; i < words.length; i++) {
+      const test = line + " " + words[i];
+      if (widthIn(test, opts) <= boxWidthIn) line = test;
+      else { out.push(line); line = words[i]; }
+    }
+    out.push(line);
+  }
+  return out;
+}
+
+/** Rendered height in inches for text wrapped into a box. */
+function heightIn(text, boxWidthIn, opts = {}) {
+  const leading = opts.lineSpacingMultiple || 1.2;
+  return wrap(text, boxWidthIn, opts).length * (opts.fontSize / 72) * leading;
+}
+
+/**
+ * Does this text fit the box? Returns a verdict object rather than a boolean so
+ * callers can report *why*.
+ */
+function fits(text, boxWidthIn, boxHeightIn, opts = {}) {
+  const lines = wrap(text, boxWidthIn, opts);
+  const h = heightIn(text, boxWidthIn, opts);
+  const widest = Math.max(...lines.map((l) => widthIn(l, opts)));
+  return {
+    ok: h <= boxHeightIn + 1e-6 && widest <= boxWidthIn + 1e-6,
+    lines: lines.length,
+    heightIn: +h.toFixed(3),
+    widestIn: +widest.toFixed(3),
+    overflowIn: +Math.max(0, h - boxHeightIn).toFixed(3),
+  };
+}
+
+/**
+ * Largest font size at or below `fontSize` that fits the box, stepping down in
+ * `step` pt increments but never below `min`. Use this instead of hardcoding a
+ * length threshold — it works for any string, in any language.
+ */
+function fitSize(text, boxWidthIn, boxHeightIn, opts = {}) {
+  const { fontSize, min = 7, step = 0.5 } = opts;
+  for (let s = fontSize; s >= min; s -= step) {
+    if (fits(text, boxWidthIn, boxHeightIn, { ...opts, fontSize: s }).ok) return s;
+  }
+  return min;
+}
+
+/** Line count only — the common case for "will this title be 2 lines or 3?". */
+const lineCount = (text, boxWidthIn, opts = {}) => wrap(text, boxWidthIn, opts).length;
+
+/**
+ * This module lives in brand/, outside any kit's `node_modules`, so Node cannot
+ * resolve `fontkit` from here. The kit that loads it hands its own copy in.
+ * Explicit beats a resolution trick that works until someone moves a directory.
+ */
+module.exports = function create(fontkit) {
+  FONTKIT = fontkit;
+  return { widthIn, wrap, heightIn, fits, fitSize, lineCount, face };
+};