wand-decks-kit 0.8.0

package/lib/schema.js

@@ -0,0 +1,399 @@
+/**
+ * lib/schema.js — the layout catalog as data.
+ *
+ * Every layout's fields, their types, and how many items it can actually draw.
+ * Three things read this and would otherwise each carry their own copy:
+ *
+ *   validate   catches a malformed spec before the build, with a path
+ *   plan       emits a per-slide stub with the right fields already in it
+ *   layouts    prints the catalog, so an operator never has to guess a key
+ *
+ * The item caps are not advice. They are the `.slice(0, n)` in the layout —
+ * a 7th item on a sixUpIcon is silently dropped, and coverage is what finds
+ * out, three steps later. Declaring them here makes it an error instead.
+ */
+
+const G = require("./shared").glyphs;
+
+const s = (type, o = {}) => ({ type, ...o });
+const str = (o) => s("string", o);
+const req = (o) => ({ required: true, ...o });
+
+/** Fields every layout takes. The full-bleed three drop the footer set. */
+const COMMON = {
+  tag: str({ note: "caps label, top-left" }),
+  dark: s("boolean", { note: "true dark, false light — alternate across the deck" }),
+  titleText: s("title", { note: "string, or [before, accentPhrase, after] for the accent-italic device" }),
+  subtitleText: str({ note: "the lede under the title" }),
+  deck: str({ note: "overrides the deck-level footer" }),
+  confidential: str(),
+};
+
+const L = {
+  /* ------------------------------------------------------------ structural */
+  cover: {
+    use: "Slide 1. Dark, full bleed, no footer",
+    bleed: true,
+    fields: {
+      eyebrow: str(), body: str(), kickerPlain: str(), kickerBold: str(),
+      titleLines: s("string[]", req({ max: 3, note: "one entry per line; auto-shrinks 46→38pt" })),
+    },
+  },
+  divider: {
+    use: "Section breaks and the agenda. Keeps the tag, drops the footer",
+    bleed: true,
+    fields: { eyebrow: str(), titleText: s("title", req()), body: str() },
+  },
+  closing: {
+    use: "Last slide. Centred, full bleed",
+    bleed: true,
+    fields: { eyebrow: str(), line1: str(req()), line2: str(), body: str(), url: str() },
+  },
+
+  /* --------------------------------------------------------------- content */
+  threeUp: {
+    use: "3 comparable things. `arrows: true` for a progression",
+    fields: {
+      arrows: s("boolean"),
+      items: s("object[]", req({ min: 2, max: 3, of: {
+        eyebrow: str(), title: str(req()), pill: str(), body: str(), emph: s("boolean"),
+      } })),
+    },
+  },
+  fourUpIcon: {
+    use: "4 attributes or capabilities",
+    fields: {
+      kickerText: str(),
+      items: s("object[]", req({ min: 3, max: 4, of: { icon: str(), title: str(req()), body: str() } })),
+    },
+  },
+  sixUpIcon: {
+    use: "6 features. Don't use it three slides running",
+    fields: {
+      items: s("object[]", req({ min: 4, max: 6, of: {
+        icon: str(), title: str(req()), body: str(), note: str({ note: "accent line under the body — a target or figure" }),
+      } })),
+    },
+  },
+  rows: {
+    use: "Stack / ownership tables. `ours: false` gets the dashed bring-your-own treatment",
+    fields: {
+      items: s("object[]", req({ min: 2, max: 5, of: {
+        icon: str(), label: str(req()), description: str(), badge: str(), ours: s("boolean"),
+      } })),
+    },
+  },
+  parity: {
+    use: "Two-sided comparison, list-shaped. The contrast between the cards is the point",
+    fields: {
+      badge: str({ note: 'the glyph in the centre circle, default "="' }),
+      badgeNote: str({ note: "caption under the centre circle" }),
+      kickerText: str(),
+      left: s("object", req({ of: { eyebrow: str(), icon: str(), label: str(req()), items: s("string[]", req({ max: 5 })) } })),
+      right: s("object", req({ of: { eyebrow: str(), icon: str(), label: str(req()), items: s("string[]", req({ max: 5 })) } })),
+    },
+  },
+  colCards: {
+    use: "2–3 layers, each with prose and a bullet list",
+    fields: {
+      items: s("object[]", req({ min: 2, max: 3, of: {
+        art: str(), eyebrow: str(), title: str(req()), sub: str(), body: str(), bullets: s("string[]"),
+      } })),
+    },
+  },
+  numberedCards: {
+    use: "Three strategic priorities — where the ordinal is the organising device",
+    fields: {
+      items: s("object[]", req({ min: 2, max: 3, of: {
+        eyebrow: str(), number: str(), title: str(req()), badge: str(), body: str(), emph: s("boolean"),
+      } })),
+    },
+  },
+  phaseCards: {
+    use: "4-step roadmaps. Card 1 is the emphasis card",
+    fields: {
+      phases: s("object[]", req({ min: 2, max: 4, of: {
+        period: str(), title: str(req()), bullets: s("string[]", { max: 5 }),
+      } })),
+    },
+  },
+  archStack: {
+    use: "Layered architecture: actors on top, your governed layer in the middle, vendors below, outcome at the base",
+    fields: {
+      top: s("object", req({ of: { label: str(req()), body: str() } })),
+      middle: s("object", req({ of: {
+        label: str(), modules: s("object[]", { max: 6, of: { title: str(req()), body: str() },
+          note: "empty renders the band as a single centred connector line" }),
+      } })),
+      note: str({ note: "one line under the module row" }),
+      sources: s("object", { note: "omit entirely for a stack that ends at the outcome band", of: {
+        eyebrow: str(), cards: s("object[]", { max: 4, of: { title: str(req()), body: str(), ours: s("boolean") } }),
+      } }),
+      outcome: str(),
+    },
+  },
+
+  /* ------------------------------------------------------------------ data */
+  statQuad: {
+    use: "4 standalone figures",
+    fields: {
+      kickerText: str(),
+      items: s("object[]", req({ min: 2, max: 4, of: { value: str(req()), caption: str() } })),
+    },
+  },
+  statGrid: {
+    use: "6 figures. Card 1 can be the emphasis card",
+    fields: {
+      footnote: str(),
+      items: s("object[]", req({ min: 3, max: 6, of: {
+        value: str(req()), label: str(), caption: str(), emph: s("boolean"),
+      } })),
+    },
+  },
+  featureStats: {
+    use: "One assertion card plus 3 supporting figures",
+    fields: {
+      lead: s("object", req({ of: { icon: str(), runs: s("object[]", req({ of: { text: str(req()), accent: s("boolean") } })) } })),
+      stats: s("object[]", req({ min: 2, max: 3, of: { value: str(req()), caption: str() } })),
+    },
+  },
+  barRank: {
+    use: "Ranked magnitudes — TAM ladders, market sizing. Not addChart()",
+    fields: {
+      footnote: str(),
+      bars: s("object[]", req({ min: 2, max: 4, of: {
+        label: str(req()), value: str(), frac: s("number", req({ note: "0–1, bar length" })),
+      } })),
+      cards: s("object[]", { max: 3, of: { icon: str(), value: str(), caption: str() } }),
+    },
+  },
+  bridge: {
+    use: "Margin bridges and waterfalls",
+    fields: {
+      eyebrow: str(),
+      rows: s("object[]", req({ min: 2, max: 5, of: { label: str(req()), value: str(), frac: s("number", req()) } })),
+      stats: s("object[]", { max: 4, of: { value: str(req()), label: str(), caption: str() } }),
+    },
+  },
+  band: {
+    use: "An equation or single assertion, usually over a stat row",
+    fields: {
+      icon: str(), quote: str(),
+      runs: s("object[]", req({ of: { text: str(req()), accent: s("boolean") } })),
+      stats: s("object[]", { max: 4, of: { value: str(req()), caption: str() } }),
+    },
+  },
+  matrixGrid: {
+    use: "Categorised inventories — use-case maps, capability grids",
+    fields: {
+      kickerText: str(),
+      groups: s("object[]", req({ min: 2, max: 4, of: {
+        category: str(req()), items: s("object[]", req({ max: 3, of: { title: str(req()), body: str() } })),
+      } })),
+    },
+  },
+  logoBands: {
+    use: "Proof points: figures over customer / investor name rows",
+    fields: {
+      stats: s("object[]", req({ min: 2, max: 4, of: { value: str(req()), caption: str() } })),
+      bands: s("object[]", req({ min: 1, max: 2, of: { label: str(req()), names: str(req()), note: str() } })),
+    },
+  },
+  heroQuad: {
+    use: "One headline figure plus a 2×2 detail grid",
+    fields: {
+      kickerText: str(),
+      hero: s("object", req({ of: {
+        pill: str(), bigValue: str(req()), bigCaption: str(), subValue: str(), subCaption: str(),
+      } })),
+      tiles: s("object[]", req({ min: 2, max: 4, of: { icon: str(), title: str(req()), body: str() } })),
+    },
+  },
+  productMap: {
+    use: "Rail-labelled product architecture (MANAGE / EXECUTE / WORKFORCE)",
+    fields: {
+      bandRow: s("object", req({ of: { rail: str(), icon: str(), title: str(req()), body: str() } })),
+      cards: s("object[]", req({ min: 2, max: 3, of: {
+        icon: str(), title: str(req()), body: str(), bullets: s("string[]"),
+      } })),
+      split: s("object", { of: { rail: str(), left: str(), right: str() } }),
+      base: str(),
+    },
+  },
+
+  /* -------------------------------------------------------------- consult */
+  problemGrid: {
+    use: "The challenge slide: a strip of today's reality, then the problems it creates",
+    fields: {
+      strip: s("object", req({ of: {
+        label: str(), chips: s("object[]", req({ max: 4, of: { title: str(req()), body: str() } })),
+      } })),
+      problems: s("object", req({ of: {
+        label: str(), items: s("object[]", req({ max: 4, of: { title: str(req()), body: str(req()) } })),
+      } })),
+    },
+  },
+  splitPanel: {
+    use: "One half argument, one half evidence",
+    fields: {
+      left: s("object", req({ of: { eyebrow: str(), heading: str(req()), body: str(), note: str() } })),
+      right: s("object", req({ of: {
+        eyebrow: str(), heading: str(),
+        items: s("object[]", req({ max: 4, of: { label: str(), body: str(req()) } })),
+      } })),
+    },
+  },
+  compareTable: {
+    use: "Reason cards over a status-quo vs ours comparison",
+    fields: {
+      reasons: s("object[]", req({ min: 2, max: 3, of: { title: str(req()), body: str() } })),
+      table: s("object", req({ of: {
+        leftHead: str(req()), rightHead: str(req()),
+        rows: s("object[]", req({ max: 4, of: { label: str(req()), left: str(req()), right: str(req()) } })),
+      } })),
+    },
+  },
+  numberedList: {
+    use: "Agendas, asks, what we'll cover",
+    fields: {
+      columns: s("number", { note: "1 or 2" }),
+      signoff: str(),
+      items: s("object[]", req({ min: 2, max: 6, of: {
+        title: str({ note: "omit when the source string cannot be split without inventing a separator" }),
+        body: str(req()),
+      } })),
+      closing: s("object", { of: { line1: str(), line2: str() } }),
+    },
+  },
+  /* --------------------------------------------------------------- client */
+  stripGrid: {
+    use: "A strip of figures, a labelled column grid, and a closing band — a year page, a scorecard, a memory model",
+    fields: {
+      stats: s("object[]", { max: 6, of: { value: str(req()), label: str(), note: str() } }),
+      lead: s("object", { of: { label: str(), text: str() } }),
+      columns: s("object[]", { max: 4, of: {
+        label: str(), items: s("object[]", req({ max: 6, of: { title: str(), body: str(req()) } })),
+      } }),
+      close: s("object", { of: { label: str(), body: str(req()) } }),
+    },
+  },
+  compareGrid: {
+    use: "A comparison wider than compareTable: up to 3 headed columns over up to 6 labelled rows",
+    fields: {
+      heads: s("string[]", { max: 3 }),
+      rows: s("object[]", req({ min: 2, max: 6, of: {
+        label: str(),
+        cells: s("object[]", req({ max: 3, of: { lead: str(), body: str() } })),
+      } })),
+    },
+  },
+};
+
+/* ---------------------------------------------------------------- validate */
+
+const TYPEOF = {
+  string: (v) => typeof v === "string",
+  number: (v) => typeof v === "number" && Number.isFinite(v),
+  boolean: (v) => typeof v === "boolean",
+  title: (v) => typeof v === "string" || (Array.isArray(v) && v.every((x) => typeof x === "string")),
+  "string[]": (v) => Array.isArray(v) && v.every((x) => typeof x === "string"),
+  "object[]": (v) => Array.isArray(v) && v.every((x) => x && typeof x === "object" && !Array.isArray(x)),
+  object: (v) => v && typeof v === "object" && !Array.isArray(v),
+};
+
+function checkFields(defs, value, path, errs, warns) {
+  for (const [key, def] of Object.entries(defs)) {
+    const v = value[key];
+    if (v == null || v === "") {
+      if (def.required) errs.push(`${path}.${key} is required${def.note ? ` — ${def.note}` : ""}`);
+      continue;
+    }
+    if (!TYPEOF[def.type](v)) {
+      errs.push(`${path}.${key} must be ${def.type}, got ${Array.isArray(v) ? "array" : typeof v}`);
+      continue;
+    }
+    if (def.type === "title" && Array.isArray(v) && v.length !== 3) {
+      warns.push(`${path}.${key} is a ${v.length}-part array — the accent-italic device expects [before, accent, after]`);
+    }
+    // An icon is either a named glyph or a legacy PNG filename. A typo used to
+    // reach the build and come out as a missing-asset error, or worse, silently
+    // resolve to a plausible wrong glyph.
+    if (key === "icon" && typeof v === "string" && !/\.\w+$/.test(v) && !G.has(v)) {
+      errs.push(`${path}.icon "${v}" is not a glyph — did you mean ${G.suggest(v).join(" / ")}?  (\`node wand.js glyphs\` lists them)`);
+    }
+    if (Array.isArray(v)) {
+      if (def.min && v.length < def.min) errs.push(`${path}.${key} needs at least ${def.min} items, has ${v.length}`);
+      if (def.max && v.length > def.max) {
+        errs.push(`${path}.${key} draws at most ${def.max} items — ${v.length - def.max} would be silently dropped`);
+      }
+      if (def.of) v.forEach((item, i) => checkFields(def.of, item, `${path}.${key}[${i}]`, errs, warns));
+    } else if (def.type === "object" && def.of) {
+      checkFields(def.of, v, `${path}.${key}`, errs, warns);
+    }
+  }
+  for (const key of Object.keys(value)) {
+    if (key.startsWith("_") || key in defs || key in COMMON || key === "layout" || key === "n" || key === "total") continue;
+    warns.push(`${path}.${key} is not a field of this layout — it will be ignored`);
+  }
+}
+
+/** Validate a whole deck spec. Returns {errors, warnings}. */
+function validate(spec) {
+  const errs = [], warns = [];
+  if (!spec || typeof spec !== "object") return { errors: ["spec is not an object"], warnings: [] };
+  if (!Array.isArray(spec.slides) || !spec.slides.length) {
+    return { errors: ["spec has no `slides` array"], warnings: [] };
+  }
+  if (!spec.deck) warns.push("spec.deck is unset — the footer will be blank");
+
+  const seen = [];
+  spec.slides.forEach((sl, i) => {
+    const path = `slides[${i}] (S${String(i + 1).padStart(2, "0")})`;
+    if (!sl.layout) return errs.push(`${path}.layout is required`);
+    const def = L[sl.layout];
+    if (!def) {
+      const near = Object.keys(L).filter((k) => k.toLowerCase().startsWith(sl.layout.slice(0, 3).toLowerCase()));
+      return errs.push(`${path}.layout "${sl.layout}" is not a layout${near.length ? ` — did you mean ${near.join(" / ")}?` : ""}`);
+    }
+    if (sl.layout === "TODO") return;
+    checkFields({ ...COMMON, ...def.fields }, sl, path, errs, warns);
+    seen.push(sl.layout);
+  });
+
+  // §5: vary the layouts, alternate the themes
+  const distinct = new Set(seen).size;
+  if (spec.slides.length >= 10 && distinct < 8) {
+    warns.push(`only ${distinct} distinct layouts across ${spec.slides.length} slides — §5 asks for at least 8`);
+  }
+  for (let i = 2; i < seen.length; i++) {
+    if (seen[i] === seen[i - 1] && seen[i] === seen[i - 2]) {
+      warns.push(`${seen[i]} runs three slides straight around S${i + 1} — §5 calls that a failure even if each one is right`);
+      break;
+    }
+  }
+  return { errors: errs, warnings: warns };
+}
+
+/** A blank spec stub for a layout, required fields only. */
+function stub(layout) {
+  const def = L[layout];
+  if (!def) return null;
+  const out = { layout };
+  if (!def.bleed) { out.tag = ""; out.dark = true; }
+  out.titleText = "";
+  const fill = (defs) => {
+    const o = {};
+    for (const [k, d] of Object.entries(defs)) {
+      if (!d.required) continue;
+      if (d.type === "object[]") o[k] = [fill(d.of || {})];
+      else if (d.type === "object") o[k] = fill(d.of || {});
+      else if (d.type === "string[]") o[k] = [""];
+      else o[k] = d.type === "boolean" ? false : d.type === "number" ? 0 : "";
+    }
+    return o;
+  };
+  Object.assign(out, fill(def.fields));
+  return out;
+}
+
+module.exports = { LAYOUTS: L, COMMON, validate, stub };

package/lib/shared.js

@@ -0,0 +1,15 @@
+/**
+ * lib/shared.js — the brand-level libraries, resolved through brand.js.
+ *
+ * measure.js and glyphs.js are about Geist and the icon set, not about decks,
+ * so they live in brand/lib and both kits load them from here. A local copy
+ * would be a second source of truth for text metrics, which is the one thing
+ * this system cannot afford.
+ */
+const path = require("path");
+const LIB = require("./brand").resolve("lib");
+module.exports = {
+  measure: require(path.join(LIB, "measure.js"))(require("fontkit")),
+  glyphs: require(path.join(LIB, "glyphs.js")),
+  pdf: require(path.join(LIB, "pdf.js")),
+};

package/lib/trace.js

@@ -0,0 +1,88 @@
+/**
+ * lib/trace.js — run a deck spec through the real layout functions, but record
+ * the shape calls instead of writing a .pptx.
+ *
+ * The point: the HTML preview must not re-implement any layout. If it did, the
+ * preview and the deck would drift the moment one was edited. Instead the same
+ * `cover()` / `archStack()` / etc. run against a fake presentation object that
+ * writes down every addShape / addText / addImage with its geometry. The
+ * browser then renders that trace. One source of truth for position, forever.
+ */
+
+function fakeSlide() {
+  const shapes = [];
+  const api = {
+    _shapes: shapes,
+    background: null,
+    addShape(type, o) { shapes.push({ kind: "shape", type, ...o }); return api; },
+    addImage(o)       { shapes.push({ kind: "image", ...o }); return api; },
+    addText(t, o)     { shapes.push({ kind: "text", runs: normaliseRuns(t), ...o }); return api; },
+    addNotes()        { return api; },
+    addChart()        { return api; },
+  };
+  Object.defineProperty(api, "background", {
+    get() { return api._bg; },
+    set(v) { api._bg = v; },
+    enumerable: true, configurable: true,
+  });
+  return api;
+}
+
+/** pptxgenjs accepts a string or an array of {text, options}. Flatten to one shape. */
+function normaliseRuns(t) {
+  if (typeof t === "string" || typeof t === "number") return [{ text: String(t), options: {} }];
+  if (Array.isArray(t)) return t.map((r) => ({ text: String(r.text ?? ""), options: r.options || {} }));
+  return [{ text: String(t?.text ?? ""), options: t?.options || {} }];
+}
+
+function fakePres() {
+  const slides = [];
+  return {
+    slides,
+    layout: null,
+    addSlide() { const s = fakeSlide(); slides.push(s); return s; },
+    writeFile() { return Promise.resolve(); },
+  };
+}
+
+/**
+ * Run a spec through the kit and return a serialisable trace.
+ * `spec` is the same deck.json the pptx build consumes.
+ */
+function trace(W, spec) {
+  const pres = fakePres();
+  pres.layout = "LAYOUT_16x9";
+  const total = spec.slides.length;
+  let n = 0;
+  const errors = [];
+
+  spec.slides.forEach((sl, i) => {
+    const fn = W[sl.layout];
+    if (typeof fn !== "function") {
+      errors.push(`slide ${i + 1}: unknown layout "${sl.layout}"`);
+      return;
+    }
+    const fullBleed = ["cover", "divider", "closing"].includes(sl.layout);
+    n += 1;
+    const args = { ...sl, n, total };
+    if (!fullBleed) {
+      args.deck = sl.deck || spec.deck;
+      args.confidential = sl.confidential || spec.confidential;
+    }
+    try { fn(pres, args); }
+    catch (e) { errors.push(`slide ${i + 1} (${sl.layout}): ${e.message}`); }
+  });
+
+  return {
+    canvas: { w: 10, h: 5.625 },
+    errors,
+    slides: pres.slides.map((s, i) => ({
+      index: i + 1,
+      layout: spec.slides[i]?.layout,
+      background: s._bg || null,
+      shapes: s._shapes,
+    })),
+  };
+}
+
+module.exports = { trace, fakePres, fakeSlide };

package/lib/ttf.py

@@ -0,0 +1,167 @@
+"""
+ttf.py — the ~1% of TrueType that embed_fonts.py needs, with no fontTools.
+
+Reads `head` and `OS/2` for the fields an EOT header carries, and rewrites the
+`name` table so a face reports the family we address it by. Weight in this
+system is carried by the family name — `Geist SemiBold` regular, not `Geist`
+bold — so retagging is not cosmetic: without it PowerPoint resolves four of the
+five families to the same face.
+
+Everything else in the font is copied through untouched.
+"""
+
+import struct
+
+_HEAD_CHECKSUM_ADJ = 8      # offset of checkSumAdjustment within `head`
+_MAGIC = 0xB1B0AFBA
+
+
+class TTFError(ValueError):
+    pass
+
+
+class TTF:
+    def __init__(self, data):
+        if len(data) < 12:
+            raise TTFError("not a font: too short")
+        tag = data[:4]
+        if tag not in (b"\x00\x01\x00\x00", b"true", b"ttcf", b"OTTO"):
+            raise TTFError(f"unrecognised sfnt tag {tag!r}")
+        if tag == b"ttcf":
+            raise TTFError("font collections (.ttc) are not supported — pass a single face")
+        self.data = data
+        self.sfnt = tag
+        (num,) = struct.unpack(">H", data[4:6])
+        self.tables = {}
+        for i in range(num):
+            off = 12 + i * 16
+            t, csum, o, ln = struct.unpack(">4sIII", data[off:off + 16])
+            self.tables[t] = (o, ln, csum)
+
+    # -- reading -----------------------------------------------------------
+
+    def table(self, tag):
+        if isinstance(tag, str):
+            tag = tag.encode()
+        if tag not in self.tables:
+            raise TTFError(f"font has no {tag.decode()} table")
+        o, ln, _ = self.tables[tag]
+        return self.data[o:o + ln]
+
+    @property
+    def check_sum_adjustment(self):
+        return struct.unpack(">I", self.table("head")[8:12])[0]
+
+    @property
+    def os2(self):
+        """The OS/2 fields the EOT header needs."""
+        t = self.table("OS/2")
+        version = struct.unpack(">H", t[0:2])[0]
+        d = {
+            "version": version,
+            "usWeightClass": struct.unpack(">H", t[4:6])[0],
+            "panose": t[32:42],
+            "ulUnicodeRange": struct.unpack(">IIII", t[42:58]),
+            "fsSelection": struct.unpack(">H", t[62:64])[0],
+        }
+        # code page ranges only exist from version 1
+        d["ulCodePageRange"] = struct.unpack(">II", t[78:86]) if version >= 1 and len(t) >= 86 else (0, 0)
+        return d
+
+    def names(self):
+        """{nameID: string} for the Windows/Unicode records, best effort."""
+        t = self.table("name")
+        count, storage = struct.unpack(">HH", t[2:6])
+        out = {}
+        for i in range(count):
+            p = 6 + i * 12
+            plat, enc, lang, nid, ln, off = struct.unpack(">HHHHHH", t[p:p + 12])
+            raw = t[storage + off: storage + off + ln]
+            try:
+                s = raw.decode("utf-16-be") if plat == 3 or (plat == 0) else raw.decode("latin-1")
+            except UnicodeDecodeError:
+                continue
+            out.setdefault(nid, s)
+        return out
+
+    # -- writing -----------------------------------------------------------
+
+    def retagged(self, family, subfamily, full, postscript):
+        """Return new font bytes with name IDs 1/2/4/6 replaced."""
+        replace = {1: family, 2: subfamily, 4: full, 6: postscript}
+        name = _rebuild_name(self.table("name"), replace)
+        return _reassemble(self, {b"name": name})
+
+
+def _rebuild_name(t, replace):
+    count, storage = struct.unpack(">HH", t[2:6])
+    records, strings, cursor = [], bytearray(), 0
+
+    for i in range(count):
+        p = 6 + i * 12
+        plat, enc, lang, nid, ln, off = struct.unpack(">HHHHHH", t[p:p + 12])
+        if nid in replace:
+            s = replace[nid]
+            raw = s.encode("utf-16-be") if plat in (0, 3) else s.encode("latin-1", "replace")
+        else:
+            raw = t[storage + off: storage + off + ln]
+        records.append((plat, enc, lang, nid, len(raw), cursor))
+        strings += raw
+        cursor += len(raw)
+
+    # sort order is required by the spec: platform, encoding, language, name
+    records.sort(key=lambda r: (r[0], r[1], r[2], r[3]))
+    head = struct.pack(">HHH", 0, len(records), 6 + len(records) * 12)
+    body = b"".join(struct.pack(">HHHHHH", *r) for r in records)
+    return head + body + bytes(strings)
+
+
+def _checksum(b):
+    if len(b) % 4:
+        b = b + b"\0" * (4 - len(b) % 4)
+    return sum(struct.unpack(f">{len(b)//4}I", b)) & 0xFFFFFFFF
+
+
+def _reassemble(font, overrides):
+    """Rewrite the whole sfnt with some tables replaced, fixing every offset,
+    every table checksum and the head checkSumAdjustment."""
+    tags = sorted(font.tables)
+    parts = {}
+    for t in tags:
+        parts[t] = overrides.get(t, font.table(t))
+
+    # head's checkSumAdjustment must be zero while the file checksum is taken
+    head = bytearray(parts[b"head"])
+    head[_HEAD_CHECKSUM_ADJ:_HEAD_CHECKSUM_ADJ + 4] = b"\0\0\0\0"
+    parts[b"head"] = bytes(head)
+
+    n = len(tags)
+    # binary-search fields the spec wants present; readers ignore them but
+    # validators complain when they are wrong
+    entry_selector = max(n.bit_length() - 1, 0)
+    search_range = (1 << entry_selector) * 16
+    out = bytearray(struct.pack(">4sHHHH", font.sfnt, n, search_range,
+                                entry_selector, n * 16 - search_range))
+
+    offset = 12 + n * 16
+    directory, body = bytearray(), bytearray()
+    for t in tags:
+        d = parts[t]
+        directory += struct.pack(">4sIII", t, _checksum(d), offset, len(d))
+        body += d
+        pad = (-len(d)) % 4
+        body += b"\0" * pad
+        offset += len(d) + pad
+
+    out += directory + body
+    adj = (_MAGIC - _checksum(bytes(out))) & 0xFFFFFFFF
+
+    head_off = struct.unpack(">I", out[12 + tags.index(b"head") * 16 + 8:
+                                       12 + tags.index(b"head") * 16 + 12])[0]
+    out[head_off + _HEAD_CHECKSUM_ADJ: head_off + _HEAD_CHECKSUM_ADJ + 4] = struct.pack(">I", adj)
+    return bytes(out)
+
+
+def load(path):
+    with open(path, "rb") as f:
+        return TTF(f.read())