fonts gate: a SHIPPED DEFAULT that cannot resolve is a note, not a block

My own over-reach, caught by CI on the previous commit: run 34973666241 failed
with test_step1_artifacts at 49 passed / 8 failed, every failure of the form "a
thing that should pass". The suite passes 57/0 on a Mac with Office fonts
installed, so the condition was invisible locally.

Cause, reproduced exactly rather than assumed: deckkit's shipped defaults are
FONT='Calibri' / MONO='Consolas' / EQFONT='Arial', and Calibri and Consolas ship
with NEITHER macOS NOR Linux. The new gate therefore blocked essentially every
deck built with library defaults — including the CI fixtures. Quarantining the
Calibri files on this machine reproduced CI's numbers to the assertion (49/8),
and restoring the downgrade produced 57/0, so the diagnosis is measured, not
inferred.

The condition is the same either way — a substituted measurement — but the
RESPONSIBILITY is not, and only one of the two is a decision anybody made:

  * a face the AUTHOR set is a choice the machine cannot honour  -> block
  * a face the LIBRARY chose is an environment fact about the host -> note,
    naming the one-call fix (deckkit.use_platform_fonts())

A gate that fires on the whole population is not a floor, it is an outage. The
note is still a strict improvement on what existed before this batch: the
condition used to be a print() in lint_layout, in no --json and gating nothing.

DEFAULT_FACES is read from deckkit's SOURCE, not the imported module: a build
script assigns dk.FONT before the gate runs, so reading the live globals would
classify every author-set face as "shipped" and defeat the split entirely. A
test pins the derived set against deckkit's live defaults, so a future re-theme
fails loudly rather than silently blocking the new default.

Verified on a host where Calibri genuinely does not resolve: a deck in the
default face is a note and blocks nothing, while a face the author chose still
blocks on that same host. test_step1_artifacts 57/0 · new suite 20/0 ·
template-branch 12/0 · slide_background 29/0 · deck_cycle 26/0 · codex delivery
gate, gate parity and the structural guards all clean.

Author: dong845

skills/slide-maker/scripts/check_fonts_resolve.py

@@ -46,6 +46,7 @@
 import argparse
 import json
 import os
+import pathlib
 import sys
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
@@ -55,6 +56,40 @@
 # wrong face is exactly the kind of thing that overflows a title band.
 MIN_CHARS = 8
 
+# 🔴 deckkit's SHIPPED DEFAULTS are reported and never blocked, however much text they carry.
+# The condition is identical either way — a substituted measurement — but the RESPONSIBILITY is
+# not, and only one of the two is a decision anybody made:
+#   * a face the author SET is a choice the machine cannot honour -> block, make them decide;
+#   * a face the LIBRARY chose is an environment fact about this host. `FONT='Calibri'` and
+#     `MONO='Consolas'` ship with neither macOS nor Linux, so blocking on them would refuse
+#     delivery of a perfectly correct deck on essentially every stock machine — including this
+#     repo's own Ubuntu CI, which is how the over-reach was caught: a suite that passes on a Mac
+#     with Office fonts installed failed 8 assertions on CI, all of them "a thing that should
+#     pass". A gate that fires on the whole population is not a floor, it is an outage.
+# The fix for this arm is one call (`deckkit.use_platform_fonts()`), and it is named in the note.
+# Read from deckkit's SOURCE, not from the live module: a build script assigns `dk.FONT = ...`
+# before this runs, so the imported globals are the deck's choice, not the library's default —
+# reading them would classify every author-set face as "shipped" and defeat the whole split.
+# The literal set is the documented fallback and a test pins the two against each other.
+_FALLBACK_DEFAULT_FACES = {"Calibri", "Consolas", "Arial", "STIX Two Math", "Cambria Math"}
+
+
+def _shipped_defaults():
+    import re as _re
+    try:
+        src = (pathlib.Path(__file__).with_name("deckkit.py")).read_text(encoding="utf8")
+    except Exception:
+        return set(_FALLBACK_DEFAULT_FACES)
+    out = set()
+    for attr in ("FONT", "MONO", "DISPLAY", "EAFONT", "EADISPLAY", "EQFONT", "EQ_MATHFONT"):
+        m = _re.search(r"^%s\s*=\s*[\"']([^\"']+)[\"']" % attr, src, _re.M)
+        if m:
+            out.add(m.group(1))
+    return out or set(_FALLBACK_DEFAULT_FACES)
+
+
+DEFAULT_FACES = _shipped_defaults()
+
 _A = "{http://schemas.openxmlformats.org/drawingml/2006/main}"
 _P = "{http://schemas.openxmlformats.org/presentationml/2006/main}"
 
@@ -164,7 +199,16 @@ def check(pptx):
         if good:
             continue
         facts["unresolved"].append(face)
-        sev = "block" if chars >= MIN_CHARS else "note"
+        shipped = face in DEFAULT_FACES
+        sev = "note" if (shipped or chars < MIN_CHARS) else "block"
+        if shipped:
+            findings.append(("note", face,
+                             "carries %d character(s) and does not resolve here, but it is one of "
+                             "deckkit's SHIPPED DEFAULTS rather than a face this deck chose — an "
+                             "environment fact about this host, not a defect in the deck. Every "
+                             "wrap/fit number for it was still measured in a stand-in: fix with "
+                             "deckkit.use_platform_fonts(), or install the face." % chars))
+            continue
         findings.append((sev, face,
                          "carries %d character(s) of this deck's text but does NOT resolve here — "
                          "every wrap, fit and overflow number computed for it was measured in a "

skills/slide-maker/tests/test_template_profile_and_fonts.py

@@ -199,6 +199,45 @@ def _with_registry(entries, fn):
     ck([f for f in finds if f[0] == "block"] == [],
        "a deck set in an installed face (%s) produces no blocking finding" % real)
 
+print("\n— fonts: a SHIPPED DEFAULT that cannot resolve is a NOTE, not a block")
+ck(CF.DEFAULT_FACES and "Calibri" in CF.DEFAULT_FACES,
+   "the shipped-default set is derived from deckkit's source: %s" % sorted(CF.DEFAULT_FACES))
+_real = CF._resolver
+CF._resolver = lambda: (lambda face: False)          # a host with NO fonts at all — CI's situation
+try:
+    with tempfile.TemporaryDirectory() as tmp:
+        deck = os.path.join(tmp, "nofonts.pptx")
+        _deck(deck, face="Calibri")
+        finds, _ = CF.check(deck)
+        sev = {f: s_ for s_, f, _ in finds}
+        ck(sev.get("Calibri") == "note",
+           "on a font-less host, a deck in deckkit's DEFAULT face is a note (%r) — blocking it "
+           "would refuse delivery on essentially every stock machine" % sev.get("Calibri"))
+        ck([f for f in finds if f[0] == "block"] == [],
+           "…and nothing in that deck blocks")
+        deck2 = os.path.join(tmp, "chosen.pptx")
+        _deck(deck2, face="Some Deliberately Chosen Face")
+        finds2, _ = CF.check(deck2)
+        ck(any(s_ == "block" and f == "Some Deliberately Chosen Face" for s_, f, _ in finds2),
+           "…while a face the author CHOSE still blocks on the same host — the split is "
+           "responsibility, not severity of the condition")
+finally:
+    CF._resolver = _real
+
+print("\n— fonts: the derived default set matches deckkit's live module defaults")
+import importlib, subprocess, json as _json
+_out = subprocess.run([sys.executable, "-c",
+    "import sys;sys.path.insert(0,'scripts');import deckkit,json;"
+    "print(json.dumps([deckkit.FONT, deckkit.MONO, deckkit.EQFONT]))"],
+    capture_output=True, text=True, cwd=os.path.dirname(HERE))
+if _out.returncode == 0:
+    live = set(_json.loads(_out.stdout))
+    ck(live <= CF.DEFAULT_FACES,
+       "every live deckkit default (%s) is in the derived set — if deckkit re-themes, this fails "
+       "rather than silently blocking the new default" % sorted(live))
+else:
+    ck(False, "could not read deckkit's live defaults: %s" % _out.stderr[-120:])
+
 print("\n— fonts: `ea` and `cs` typefaces are counted, not only `latin`")
 ck("ea" in open(os.path.join(os.path.dirname(HERE), "scripts",
                              "check_fonts_resolve.py")).read(),