@multiplatform.one/theme 7.5.0 → 7.6.0

package/src/index.ts

@@ -7,5 +7,17 @@ export * from "./menuRow";
 export * from "./font";
 export * from "./fonts/index";
 
+// Contrast + matrix assertions downstream repos call (MPO-18). The full
+// audit surface including the browser-side capturer stays on ./audit.
+export { diffGeometry, evaluateNoBreakage, evaluateTextContrast } from "./audit";
+export type {
+  GeometryDiff,
+  MatrixTextSample,
+  NoBreakageInput,
+  NoBreakageResult,
+  TextContrastResult,
+  TextContrastViolation,
+} from "./audit";
+
 // Thin type re-exports so packages/apps never import @tamagui/web directly.
 export type { GenericFonts, MediaQueryKey, ThemeName } from "@tamagui/web";

package/src/theme/FontKnobStyles.tsx

@@ -27,6 +27,7 @@
  */
 import { getConfig } from "@tamagui/web";
 import { useEffect } from "react";
+import { fontCategoryMetrics, flooredLineHeight } from "./fontCategoryMetrics";
 import { fontCategoryStacks } from "./fontCategoryStacks";
 import type { FontCategory } from "./knobs";
 import { defaultKnobs } from "./knobs";
@@ -35,32 +36,12 @@ import { usePresetContext } from "./PresetContext";
 const STYLE_TAG_ID = "mp-font-knob-styles";
 
 /**
- * Per-category legibility floors, applied on top of the base (Inter-tuned)
- * lineHeight tables when the heading/body knob selects that category.
- * `heading`/`body` are minimum lineHeight:fontSize ratios; `letterSpacing:
- * "neutral"` zeroes Inter's tracking-by-size curve (wrong for fixed-pitch
- * and connected-script families). "sans-serif" is the default scope (never
- * overridden), listed for completeness.
+ * Re-exported so `@multiplatform.one/theme` consumers keep the historical
+ * import path. The table itself lives in `fontCategoryMetrics.ts` because
+ * `defaults/fonts.ts` bakes the same floors into the registered category
+ * fonts and the two must not drift (LC-11).
  */
-export const fontCategoryMetrics: Record<
-  FontCategory,
-  { heading: number; body: number; letterSpacing: "inherit" | "neutral" }
-> = {
-  "sans-serif": { heading: 1.15, body: 1.4, letterSpacing: "inherit" },
-  serif: { heading: 1.2, body: 1.4, letterSpacing: "inherit" },
-  mono: { heading: 1.25, body: 1.45, letterSpacing: "neutral" },
-  // Heading floors below are sized to each configured face's em box
-  // (ascent+descent) so display headings never clip (LC-11): Roboto Slab
-  // ≈1.32, Nunito ≈1.36, Silkscreen ≈1.3, Poppins/Futura ≈1.4.
-  slab: { heading: 1.35, body: 1.4, letterSpacing: "inherit" },
-  rounded: { heading: 1.4, body: 1.4, letterSpacing: "inherit" },
-  condensed: { heading: 1.15, body: 1.4, letterSpacing: "inherit" },
-  cursive: { heading: 1.3, body: 1.5, letterSpacing: "neutral" },
-  handwriting: { heading: 1.25, body: 1.45, letterSpacing: "neutral" },
-  pixel: { heading: 1.35, body: 1.4, letterSpacing: "neutral" },
-  blackletter: { heading: 1.3, body: 1.45, letterSpacing: "neutral" },
-  geometric: { heading: 1.45, body: 1.4, letterSpacing: "inherit" },
-};
+export { fontCategoryMetrics };
 
 // Default leading for font-scoped text that carries no explicit lineHeight
 // (e.g. `Text fontFamily="$body" fontSize=…` renders `line-height: normal`
@@ -166,9 +147,9 @@ function buildScopeRule(
     for (const [key, size] of Object.entries(tables.size)) {
       const baseLineHeight = tables.lineHeight[key];
       if (typeof baseLineHeight !== "number") continue;
-      const floor = Math.round(size * minRatio);
-      if (baseLineHeight < floor) {
-        decls.push(`--f-lineHeight-${key}: ${floor}px !important`);
+      const floored = flooredLineHeight(size, baseLineHeight, minRatio);
+      if (floored > baseLineHeight) {
+        decls.push(`--f-lineHeight-${key}: ${floored}px !important`);
       }
     }
     if (metrics.letterSpacing === "neutral" && tables.letterSpacing) {

package/src/theme/colorRules.spec.ts

@@ -424,3 +424,76 @@ describe("contrast floor on built themes (DG-A11Y-01 / DG-COL-01)", () => {
     ).toThrow(/light_accent: color on background: #f9f8fc on #eeecf9 = 1.1:1/);
   });
 });
+
+describe("intent color11 on the base page surfaces (MPO-40)", () => {
+  const themes = createThemesBuilder(
+    defaultBaseTheme,
+    defaultAccentTheme,
+    defaultBuilderOptions,
+  ).themes() as Record<string, Record<string, string>>;
+
+  const schemes = ["light", "dark"] as const;
+  const intents = ["error", "warning", "success"] as const;
+  // The surfaces an outlined control's TRANSPARENT frame can sit on. The
+  // intent sub-theme supplies the ink; the page behind it supplies the
+  // ground, so the pair is cross-theme and `resolveThemeContrast` (one
+  // theme) cannot address it.
+  const surfaces = ["background", "color1", "color2"] as const;
+
+  const intentInkPairs = schemes.flatMap((scheme) =>
+    intents.flatMap((intent) =>
+      surfaces.map((surface) => ({
+        foreground: themes[`${scheme}_${intent}`].color11,
+        background: themes[scheme][surface],
+        label: `${scheme}_${intent}: color11 on ${scheme}.${surface}`,
+      })),
+    ),
+  );
+
+  /**
+   * MPO-40 measured the outlined intent label on the gallery harness ground
+   * and recorded warning 4.34:1 and success 4.48:1. That ground is the BASE
+   * theme's `color2` (#f9f9fa) — NOT `background`/`color1`, which are both
+   * #ffffff and where the same two pairs clear the floor at 4.57 and 4.72.
+   * The miss is therefore surface-specific: an outlined warning or success
+   * Button only goes unreadable once it sits on a color2 surface (a card, a
+   * striped row, the gallery ground). Measuring against the plain page is
+   * exactly how a check reports a pass on a control that is failing.
+   *
+   * The two misses are PINNED to their measured ratios rather than skipped.
+   * Raise the $color11 step and the recorded ratio stops matching, which
+   * fails here and forces the entry out of this table — an exemption that
+   * retires itself instead of one that rots.
+   */
+  const pinnedMisses: Record<string, number> = {
+    "light_warning: color11 on light.color2": 4.34,
+    "light_success: color11 on light.color2": 4.48,
+  };
+
+  it("sweeps every intent x base surface x scheme — 18 pairs, none dropped", () => {
+    expect(intentInkPairs).toHaveLength(18);
+  });
+
+  it("clears AA everywhere except the two pinned MPO-40 misses", () => {
+    const misses = intentInkPairs
+      .map(measureContrast)
+      .filter((report) => !report.pass)
+      .map((report) => [report.label, report.ratio] as const);
+    expect(Object.fromEntries(misses)).toEqual(pinnedMisses);
+  });
+
+  it("the same warning/success ink clears the floor on background and color1", () => {
+    // Locks the surface-specificity so a future fix cannot be signed off by
+    // re-measuring against the white page.
+    const reports = assertContrast(
+      (["warning", "success"] as const).flatMap((intent) =>
+        (["background", "color1"] as const).map((surface) => ({
+          foreground: themes[`light_${intent}`].color11,
+          background: themes.light[surface],
+          label: `light_${intent}: color11 on light.${surface}`,
+        })),
+      ),
+    );
+    expect(reports.map((report) => report.ratio)).toEqual([4.57, 4.57, 4.72, 4.72]);
+  });
+});

package/src/theme/cornerSmoothing.spec.ts

@@ -1,5 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdtempSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readdirSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createElement, type ReactNode } from "react";
@@ -26,11 +26,40 @@ import {
   readComputedCornerShape,
 } from "./cornerSmoothing";
 
+/**
+ * Playwright's `chrome-headless-shell` builds, newest revision first.
+ *
+ * This is about coverage, not speed — an installed Chrome reaches `--dump-dom`
+ * in ~5s and is fine. The point is that a machine or a CI image with no Chrome
+ * installed but a Playwright cache present would otherwise take the held-out
+ * branch below and prove nothing, silently.
+ */
+function findHeadlessShells(): string[] {
+  const home = process.env.HOME ?? "";
+  const roots = [`${home}/Library/Caches/ms-playwright`, `${home}/.cache/ms-playwright`];
+  const found: { revision: number; bin: string }[] = [];
+  for (const root of roots) {
+    if (!existsSync(root)) continue;
+    for (const entry of readdirSync(root)) {
+      const revision = Number(entry.replace("chromium_headless_shell-", ""));
+      if (!entry.startsWith("chromium_headless_shell-") || Number.isNaN(revision)) continue;
+      for (const arch of ["mac-arm64", "mac-x64", "linux64"]) {
+        const bin = join(root, entry, `chrome-headless-shell-${arch}`, "chrome-headless-shell");
+        if (existsSync(bin)) found.push({ revision, bin });
+      }
+    }
+  }
+  return found.sort((a, b) => b.revision - a.revision).map((f) => f.bin);
+}
+
 function findChrome(): string | undefined {
   const candidates = [
     process.env.CHROME_BIN,
+    ...findHeadlessShells(),
     "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
     `${process.env.HOME ?? ""}/.local/bin/google-chrome`,
+    "/usr/bin/google-chrome",
+    "/usr/bin/chromium",
   ].filter((p): p is string => Boolean(p));
   return candidates.find((p) => existsSync(p));
 }
@@ -188,26 +217,42 @@ describe("cornerSmoothing (Axiom 15 OPTICS)", () => {
       writeFileSync(
         htmlPath,
         `<!doctype html><style>
-.box { width: 132px; height: 84px; border-radius: 16px; }
-.round { corner-shape: round; }
-.smooth { corner-shape: squircle; }
+html, body { margin: 0; padding: 0; }
+.box { position: absolute; top: 0; width: 132px; height: 84px; border-radius: 16px; }
+.round { left: 0; corner-shape: round; }
+.smooth { left: 200px; corner-shape: squircle; }
+.classy { left: 400px; }
 .${cornerSmoothClassName} { corner-shape: squircle; }
 </style>
 <div id="round" class="box round"></div>
 <div id="smooth" class="box smooth"></div>
-<div id="classy" class="box ${cornerSmoothClassName}"></div>
+<div id="classy" class="box classy ${cornerSmoothClassName}"></div>
 <pre id="out"></pre>
 <script>
 const read = (el) => {
   const cs = getComputedStyle(el);
   return (cs.getPropertyValue("corner-shape") || cs.cornerShape || "").trim();
 };
+// Walk 1px..8px diagonally in from the top-left. "1" means the box owns that
+// pixel. This reads the PAINTED curve, so it fails if an engine parses
+// corner-shape but still draws the plain arc — a property echo cannot fake it.
+const cornerMask = (id, left) => {
+  let bits = "";
+  for (let d = 1; d <= 8; d++) {
+    const hit = document.elementFromPoint(left + d, d);
+    bits += hit && hit.id === id ? "1" : "0";
+  }
+  return bits;
+};
 const out = {
   supportsSquircle: CSS.supports("corner-shape", "squircle"),
   ua: navigator.userAgent,
   round: read(document.getElementById("round")),
   smooth: read(document.getElementById("smooth")),
   classy: read(document.getElementById("classy")),
+  roundCorner: cornerMask("round", 0),
+  smoothCorner: cornerMask("smooth", 200),
+  classyCorner: cornerMask("classy", 400),
 };
 document.getElementById("out").textContent = JSON.stringify(out);
 </script>`,
@@ -215,7 +260,7 @@ document.getElementById("out").textContent = JSON.stringify(out);
       const dump = execFileSync(
         chrome,
         ["--headless=new", "--disable-gpu", "--dump-dom", `file://${htmlPath}`],
-        { encoding: "utf8", timeout: 25_000 },
+        { encoding: "utf8", timeout: 60_000 },
       );
       const match = dump.match(/<pre id="out">([\s\S]*?)<\/pre>/);
       expect(match, "probe <pre id=out> missing from dump-dom").toBeTruthy();
@@ -224,6 +269,9 @@ document.getElementById("out").textContent = JSON.stringify(out);
         round: string;
         smooth: string;
         classy: string;
+        roundCorner: string;
+        smoothCorner: string;
+        classyCorner: string;
       };
       expect(result.supportsSquircle).toBe(true);
       expect(isRoundComputedCornerShape(result.round)).toBe(true);
@@ -232,6 +280,15 @@ document.getElementById("out").textContent = JSON.stringify(out);
       expect(result.smooth).not.toBe(result.round);
       expect([CORNER_SHAPE_SMOOTH, CORNER_SHAPE_SMOOTH_COMPUTED]).toContain(result.smooth);
       expect([CORNER_SHAPE_ROUND, CORNER_SHAPE_ROUND_COMPUTED]).toContain(result.round);
+
+      // Geometry, not the property echo: the squircle claims corner pixels the
+      // arc leaves empty, and the class-driven cell paints the same curve as
+      // the hand-written one. Measured 2026-09-01 on Chromium 143/147/148/151
+      // and Chrome 152 — round "00011111", smooth "01111111". See
+      // docs/design/boards/W1-corner-smoothing/engines__corner-shape.json.
+      expect(result.smoothCorner).not.toBe(result.roundCorner);
+      expect(result.classyCorner).toBe(result.smoothCorner);
+      expect(result.smoothCorner.indexOf("1")).toBeLessThan(result.roundCorner.indexOf("1"));
     });
   });
 });

package/src/theme/cornerSmoothing.ts

@@ -29,6 +29,21 @@
  *   is false and computed `corner-shape` is empty — the silent fallback,
  *   measured rather than assumed. Native has no `corner-shape`.
  *
+ * Re-measured 2026-09-01 across seven engines — the matrix and the probe that
+ * produced it live in `docs/design/boards/W1-corner-smoothing/`:
+ * - The property is live from at least Chromium 143, four minor versions
+ *   below the 147 the INERT caption was shot on.
+ * - The computed serialization is NOT stable: it echoes the specified keyword
+ *   (`round` / `squircle`) through 151 and normalizes to `superellipse(1)` /
+ *   `superellipse(2)` from 152. Classify with the two helpers below; never
+ *   compare a raw string.
+ * - The painted corner differs at both stops on every Chromium, read as
+ *   geometry (`elementFromPoint` walking in from the corner), so the channel
+ *   is proven to paint and not merely to parse.
+ * - WebKit 26 and Firefox 148: `CSS.supports` false, computed `corner-shape`
+ *   empty, `border-radius` and the box footprint untouched, and the corner
+ *   byte-identical between the stops. Silent degradation on a real engine.
+ *
  * Native twin: `cornerSmoothing.native.ts` (no CSS classes — native
  * resolves to `round` until a SquircleView adoption lands, phase 2).
  */

package/src/theme/defaults/categoryFonts.ts

@@ -1,21 +1,24 @@
-import { createDefaultFont } from "../../font";
-import { fontCategoryStacks } from "../fontCategoryStacks";
+import { defaultFonts } from "./fonts";
 
 /**
  * Category fonts merged into createDefaultThemeConfig UNDER consumer
  * heading/body overrides. FontKnobStyles looks these up as `$serif` etc.
  * so headingFont=serif writes `--f-family` even when the app only customizes
  * heading/body (SHC console Operator).
+ *
+ * Picked out of `defaultFonts` rather than built a second time: two
+ * construction paths meant `$mono` could be registered from one stack here
+ * and another there, which is the same one-source failure MPO-44 was about.
  */
 export const defaultCategoryFonts = {
-  serif: createDefaultFont({ family: fontCategoryStacks.serif }),
-  mono: createDefaultFont({ family: fontCategoryStacks.mono }),
-  slab: createDefaultFont({ family: fontCategoryStacks.slab }),
-  rounded: createDefaultFont({ family: fontCategoryStacks.rounded }),
-  condensed: createDefaultFont({ family: fontCategoryStacks.condensed }),
-  cursive: createDefaultFont({ family: fontCategoryStacks.cursive }),
-  handwriting: createDefaultFont({ family: fontCategoryStacks.handwriting }),
-  pixel: createDefaultFont({ family: fontCategoryStacks.pixel }),
-  blackletter: createDefaultFont({ family: fontCategoryStacks.blackletter }),
-  geometric: createDefaultFont({ family: fontCategoryStacks.geometric }),
+  serif: defaultFonts.serif,
+  mono: defaultFonts.mono,
+  slab: defaultFonts.slab,
+  rounded: defaultFonts.rounded,
+  condensed: defaultFonts.condensed,
+  cursive: defaultFonts.cursive,
+  handwriting: defaultFonts.handwriting,
+  pixel: defaultFonts.pixel,
+  blackletter: defaultFonts.blackletter,
+  geometric: defaultFonts.geometric,
 };

package/src/theme/defaults/fonts.spec.ts

@@ -1,8 +1,9 @@
 import { describe, expect, it } from "vitest";
 import { createDefaultFont } from "../../font";
+import { flooredLineHeight, fontCategoryMetrics } from "../fontCategoryMetrics";
+import { fontCategoryStacks } from "../fontCategoryStacks";
+import type { FontCategory } from "../knobs";
 import {
-  BODY_LINE_HEIGHT_OFFSET,
-  bodyLineHeightPx,
   defaultBodyFont,
   defaultFonts,
   defaultHeadingFont,
@@ -23,6 +24,17 @@ function table(font: unknown, key: "size" | "lineHeight" | "letterSpacing"): Num
   return out;
 }
 
+/** Unwrap a font table whose values are strings (weight). */
+function strTable(font: unknown, key: "weight"): Record<string, string> {
+  const raw = (font as Record<string, Record<string, string | { val: string }>>)[key] ?? {};
+  const out: Record<string, string> = {};
+  for (const [k, v] of Object.entries(raw)) {
+    const str = typeof v === "string" ? v : v && typeof v.val === "string" ? v.val : undefined;
+    if (str !== undefined) out[k.replace(/^\$/, "")] = str;
+  }
+  return out;
+}
+
 describe("default heading/body fonts — tracking-by-size (Axiom 15 OPTICS, LC-11)", () => {
   for (const [name, font] of [
     ["heading", defaultHeadingFont],
@@ -97,69 +109,127 @@ describe("default heading/body fonts — tracking-by-size (Axiom 15 OPTICS, LC-1
   });
 });
 
-describe("bodyFont category fonts — distinct families on the size+10 ramp (MPO-44)", () => {
+describe("bodyFont category fonts — one ladder, distinct families (MPO-44)", () => {
   const bodyStops = ["body", "serif", "mono", "rounded"] as const;
   const firstFamily = (stack: string) => stack.split(",")[0]?.replace(/['"]/g, "").trim();
+  const categories = Object.keys(defaultFonts).filter(
+    (name) => name !== "heading" && name !== "body",
+  ) as FontCategory[];
+  const bodySize = table(defaultBodyFont, "size");
+  const bodyLineHeight = table(defaultBodyFont, "lineHeight");
 
   it("registers every category token the bodyFont knob maps to", () => {
-    for (const key of [
-      "serif",
-      "mono",
-      "slab",
-      "rounded",
-      "condensed",
-      "cursive",
-      "handwriting",
-      "pixel",
-      "blackletter",
-      "geometric",
-    ] as const) {
+    expect(categories.length).toBe(10);
+    for (const key of categories) {
       expect(defaultFonts[key], key).toBeTruthy();
-      expect(fontFamily(defaultFonts[key])).toBe(fontFamilyStacks[key]);
+      expect(fontFamily(defaultFonts[key])).toBe(fontCategoryStacks[key]);
     }
     expect(fontFamily(defaultFonts.body)).toContain("Inter");
   });
 
+  it("aliases fontFamilyStacks to the one fontCategoryStacks table", () => {
+    expect(fontFamilyStacks).toBe(fontCategoryStacks);
+  });
+
   it("gives the four bodyFont stops four distinct first families", () => {
     const firsts = bodyStops.map((key) => firstFamily(fontFamily(defaultFonts[key])));
     expect(firsts).toEqual(["Inter", "Georgia", "ui-monospace", "Nunito"]);
     expect(new Set(firsts).size).toBe(4);
   });
 
-  it("keeps category-font $true at 14px / 24px — never missing true", () => {
-    for (const [name, font] of Object.entries(defaultFonts)) {
-      if (name === "heading" || name === "body") continue;
-      const size = table(font, "size");
-      const lineHeight = table(font, "lineHeight");
-      expect(size.true, `${name}.size.true`).toBe(14);
-      expect(size["4"], `${name}.size.4`).toBe(14);
-      expect(lineHeight.true, `${name}.lineHeight.true`).toBe(24);
-      expect(lineHeight["4"], `${name}.lineHeight.4`).toBe(24);
+  it("every knob stop has a distinct first family — none is a system fallback", () => {
+    const firsts = ["body", ...categories].map((key) =>
+      firstFamily(fontFamily(defaultFonts[key as keyof typeof defaultFonts])),
+    );
+    expect(new Set(firsts).size).toBe(firsts.length);
+    expect(firsts).not.toContain("-apple-system");
+  });
+
+  it("puts every category font on the $body SIZE ladder — a family knob never resizes", () => {
+    for (const name of categories) {
+      expect(table(defaultFonts[name], "size"), `${name}.size`).toEqual(bodySize);
     }
   });
 
-  it("puts every category-font size on the size+10 ramp", () => {
-    for (const [name, font] of Object.entries(defaultFonts)) {
-      if (name === "heading" || name === "body") continue;
-      const size = table(font, "size");
-      const lineHeight = table(font, "lineHeight");
+  it("renders 15px/23px at $true and $4 on every stop, body included", () => {
+    for (const name of ["body", ...categories] as const) {
+      const size = table(defaultFonts[name as keyof typeof defaultFonts], "size");
+      const lineHeight = table(defaultFonts[name as keyof typeof defaultFonts], "lineHeight");
+      expect(size.true, `${name}.size.true`).toBe(15);
+      expect(size["4"], `${name}.size.4`).toBe(15);
+      expect(lineHeight.true, `${name}.lineHeight.true`).toBe(23);
+      expect(lineHeight["4"], `${name}.lineHeight.4`).toBe(23);
+    }
+  });
+
+  it("takes the era's leading, raised to the category floor and never lowered (LC-11)", () => {
+    for (const name of categories) {
+      const lineHeight = table(defaultFonts[name], "lineHeight");
+      const minRatio = fontCategoryMetrics[name].body;
+      for (const [key, px] of Object.entries(bodySize)) {
+        expect(lineHeight[key], `${name}.lineHeight[${key}]`).toBe(
+          flooredLineHeight(px, bodyLineHeight[key] as number, minRatio),
+        );
+        expect(lineHeight[key]).toBeGreaterThanOrEqual(bodyLineHeight[key] as number);
+        expect((lineHeight[key] as number) / px, `${name} ratio at ${key}`).toBeGreaterThanOrEqual(
+          minRatio - 0.034,
+        );
+      }
+    }
+  });
+
+  it("meets the LC-11 body floor at every size on every category", () => {
+    for (const name of categories) {
+      const size = table(defaultFonts[name], "size");
+      const lineHeight = table(defaultFonts[name], "lineHeight");
       for (const [key, px] of Object.entries(size)) {
-        expect(lineHeight[key], `${name}.lineHeight[${key}]`).toBe(bodyLineHeightPx(px));
-        expect(lineHeight[key]).toBe(px + BODY_LINE_HEIGHT_OFFSET);
+        expect((lineHeight[key] as number) / px, `${name} ratio at ${key}`).toBeGreaterThan(1.36);
+      }
+    }
+  });
+
+  it("carries the era's weight, not the legacy 300", () => {
+    for (const name of categories) {
+      const weight = strTable(defaultFonts[name], "weight");
+      for (const key of Object.keys(bodySize)) {
+        expect(weight[key], `${name}.weight[${key}]`).toBe("400");
+      }
+    }
+  });
+
+  it("zeroes tracking on every category face so Inter's curve cannot leak in", () => {
+    for (const name of categories) {
+      const letterSpacing = table(defaultFonts[name], "letterSpacing");
+      expect(Object.keys(letterSpacing).sort(), `${name}.letterSpacing keys`).toEqual(
+        Object.keys(bodySize).sort(),
+      );
+      for (const key of Object.keys(bodySize)) {
+        expect(letterSpacing[key], `${name}.letterSpacing[${key}]`).toBe(0);
       }
     }
   });
 });
 
-describe("createDefaultFont — body ramp (MPO-44)", () => {
-  it("includes $true at 14/24 so app category fonts do not collapse to normal", () => {
+describe("createDefaultFont — the era body ramp (MPO-44)", () => {
+  it("includes $true at 15/23 so app category fonts do not collapse to normal", () => {
     const font = createDefaultFont({ family: "Georgia, serif" });
     const size = table(font, "size");
     const lineHeight = table(font, "lineHeight");
-    expect(size.true).toBe(14);
-    expect(lineHeight.true).toBe(24);
+    expect(size.true).toBe(15);
+    expect(lineHeight.true).toBe(23);
     expect(fontFamily(font)).toBe("Georgia, serif");
   });
+
+  it("lands a consumer font on the same ladder as the built-in category fonts", () => {
+    const font = createDefaultFont({ family: "Georgia, serif" });
+    expect(table(font, "size")).toEqual(table(defaultFonts.serif, "size"));
+    expect(table(font, "lineHeight")).toEqual(table(defaultFonts.rounded, "lineHeight"));
+  });
+
+  it("defaults to weight 400, never the legacy 300", () => {
+    const weight = strTable(createDefaultFont({ family: "Georgia, serif" }), "weight");
+    expect(weight["4"]).toBe("400");
+  });
 });
 
 function fontFamily(font: unknown): string {